mirror of
https://codeberg.org/unspeaker/tek.git
synced 2025-12-06 03:36:41 +01:00
795 lines
31 KiB
Rust
795 lines
31 KiB
Rust
use crate::*;
|
|
pub(crate) use std::fmt::Write;
|
|
pub(crate) use ::tengri::tui::ratatui::prelude::Position;
|
|
|
|
mod view_output; pub use self::view_output::*;
|
|
|
|
#[tengri_proc::view(TuiOut)]
|
|
impl App {
|
|
pub fn view_nil (&self) -> impl Content<TuiOut> + use<'_> {
|
|
"nil"
|
|
}
|
|
pub fn view_status (&self) -> impl Content<TuiOut> + use<'_> {
|
|
self.update_clock();
|
|
let cache = self.view_cache.read().unwrap();
|
|
view_status(self.selected.describe(&self.tracks, &self.scenes),
|
|
cache.sr.view.clone(), cache.buf.view.clone(), cache.lat.view.clone())
|
|
}
|
|
pub fn view_transport (&self) -> impl Content<TuiOut> + use<'_> {
|
|
self.update_clock();
|
|
let cache = self.view_cache.read().unwrap();
|
|
view_transport(self.clock.is_rolling(),
|
|
cache.bpm.view.clone(), cache.beat.view.clone(), cache.time.view.clone())
|
|
}
|
|
pub fn view_arranger (&self) -> impl Content<TuiOut> + use<'_> {
|
|
ArrangerView::new(self)
|
|
}
|
|
pub fn view_pool (&self) -> impl Content<TuiOut> + use<'_> {
|
|
self.pool().map(|p|Fixed::x(self.w_sidebar(), PoolView(self.is_editing(), p)))
|
|
}
|
|
pub fn view_editor (&self) -> impl Content<TuiOut> + use<'_> {
|
|
self.editor().map(|e|Bsp::n(Bsp::e(e.clip_status(), e.edit_status()), e))
|
|
}
|
|
pub fn view_samples_keys (&self) -> impl Content<TuiOut> + use<'_> {
|
|
self.sampler().map(|s|s.view_list(false, self.editor().unwrap()))
|
|
}
|
|
pub fn view_samples_grid (&self) -> impl Content<TuiOut> + use<'_> {
|
|
self.sampler().map(|s|s.view_grid())
|
|
}
|
|
pub fn view_sample_viewer (&self) -> impl Content<TuiOut> + use<'_> {
|
|
self.sampler().map(|s|s.view_sample(self.editor().unwrap().get_note_pos()))
|
|
}
|
|
pub fn view_sample_info (&self) -> impl Content<TuiOut> + use<'_> {
|
|
self.sampler().map(|s|s.view_sample_info(self.editor().unwrap().get_note_pos()))
|
|
}
|
|
pub fn view_meters_input (&self) -> impl Content<TuiOut> + use<'_> {
|
|
self.sampler().map(|s|s.view_meters_input())
|
|
}
|
|
pub fn view_meters_output (&self) -> impl Content<TuiOut> + use<'_> {
|
|
self.sampler().map(|s|s.view_meters_output())
|
|
}
|
|
pub fn view_dialog (&self) -> impl Content<TuiOut> + use<'_> {
|
|
When::new(self.dialog.is_some(), Bsp::b(
|
|
Fill::xy(Tui::fg_bg(Rgb(64,64,64), Rgb(32,32,32), "")),
|
|
Fixed::xy(30, 15, Tui::fg_bg(Rgb(255,255,255), Rgb(16,16,16), Bsp::b(
|
|
Repeat(" "),
|
|
Outer(true, Style::default().fg(Tui::g(96)))
|
|
.enclose(self.dialog.as_ref().map(|dialog|match dialog {
|
|
Dialog::Menu => self.view_dialog_menu().boxed(),
|
|
Dialog::Help => self.view_dialog_help().boxed(),
|
|
Dialog::Save => self.view_dialog_save().boxed(),
|
|
Dialog::Load => self.view_dialog_load().boxed(),
|
|
Dialog::Options => self.view_dialog_options().boxed(),
|
|
Dialog::Device(index) => self.view_dialog_device(*index).boxed(),
|
|
Dialog::Message(message) => self.view_dialog_message(message).boxed(),
|
|
}))
|
|
)))
|
|
))
|
|
}
|
|
}
|
|
|
|
impl App {
|
|
fn view_dialog_menu (&self) -> impl Content<TuiOut> {
|
|
let options = ||["Projects", "Settings", "Help", "Quit"].iter();
|
|
let option = |a,i|Tui::fg(Rgb(255,255,255), format!("{}", a));
|
|
Bsp::s(Tui::bold(true, "tek!"), Bsp::s("", Map::south(1, options, option)))
|
|
}
|
|
fn view_dialog_help (&self) -> impl Content<TuiOut> + use<'_> {
|
|
let bindings = ||self.config.keys.layers.iter()
|
|
.filter_map(|a|(a.0)(self).then_some(a.1))
|
|
.flat_map(|a|a)
|
|
.filter_map(|x|if let Value::Exp(_, iter)=x.value{
|
|
Some(iter)
|
|
} else {
|
|
None
|
|
});
|
|
//let binding = ;[> Bsp::e(
|
|
//Fixed::x(15, Align::w(Tui::bold(true, Tui::fg(Rgb(255,192,0), if let Some(Token {
|
|
//value: Value::Sym(key), ..
|
|
//}) = binding.next() {
|
|
//Some(key.to_string())
|
|
//} else {
|
|
//None
|
|
//})))),
|
|
//Bsp::e(" ", Tui::fg(Rgb(255,255,255), if let Some(Token {
|
|
//value: Value::Key(command), ..
|
|
//}) = binding.next() {
|
|
//Some(command.to_string())
|
|
//} else {
|
|
//None
|
|
//})),
|
|
//);*/
|
|
Bsp::s(Tui::bold(true, "Help"), Bsp::s("", Map::south(1, bindings, |b,i|format!("{i}:{b:?}"))))
|
|
//|mut binding: TokenIter, _|Map::east(5, move||binding.clone(), |_,_|"kyp"))))
|
|
}
|
|
|
|
fn view_dialog_device (&self, index: usize) -> impl Content<TuiOut> + use<'_> {
|
|
let choices = ||self.device_kinds().iter();
|
|
let choice = move|label, i|
|
|
Fill::x(Tui::bg(if i == index { Rgb(64,128,32) } else { Rgb(0,0,0) },
|
|
Bsp::e(if i == index { "[ " } else { " " },
|
|
Bsp::w(if i == index { " ]" } else { " " },
|
|
label))));
|
|
Bsp::s(Tui::bold(true, "Add device"), Map::south(1, choices, choice))
|
|
}
|
|
|
|
fn view_dialog_message <'a> (&'a self, message: &'a Message) -> impl Content<TuiOut> + use<'a> {
|
|
Bsp::s(message, Bsp::s("", "[ OK ]"))
|
|
}
|
|
|
|
fn view_dialog_save <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
|
|
"WIP: SAVE"
|
|
}
|
|
|
|
fn view_dialog_load <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
|
|
"WIP: LOAD"
|
|
}
|
|
|
|
fn view_dialog_options <'a> (&'a self) -> impl Content<TuiOut> + use<'a> {
|
|
"WIP: OPTIONS"
|
|
}
|
|
|
|
/// Spacing between tracks.
|
|
pub(crate) const TRACK_SPACING: usize = 0;
|
|
|
|
/// Default scene height.
|
|
pub(crate) const H_SCENE: usize = 2;
|
|
|
|
/// Default editor height.
|
|
pub(crate) const H_EDITOR: usize = 15;
|
|
|
|
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 tracks_with_sizes (&self) -> impl TracksSizes<'_> {
|
|
use Selection::*;
|
|
let mut x = 0;
|
|
let editing = self.is_editing();
|
|
let active = match self.selected() {
|
|
Track(t) if editing => Some(t),
|
|
TrackClip { track, .. } if editing => Some(track),
|
|
_ => 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 + App::TRACK_SPACING;
|
|
data
|
|
})
|
|
}
|
|
|
|
pub(crate) fn scenes_with_sizes (&self, editing: bool, height: usize, larger: usize)
|
|
-> impl ScenesSizes<'_>
|
|
{
|
|
use Selection::*;
|
|
let (selected_track, selected_scene) = match self.selected() {
|
|
Track(t) => (Some(*t), None),
|
|
Scene(s) => (None, Some(*s)),
|
|
TrackClip { track, scene } => (Some(*track), Some(*scene)),
|
|
_ => (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 fn update_clock (&self) {
|
|
ViewCache::update_clock(&self.view_cache, self.clock(), self.size.w() > 80)
|
|
}
|
|
|
|
}
|
|
|
|
pub(crate) struct ArrangerView<'a> {
|
|
app: &'a App,
|
|
|
|
is_editing: bool,
|
|
|
|
width: u16,
|
|
width_mid: u16,
|
|
width_side: u16,
|
|
|
|
inputs_count: usize,
|
|
inputs_height: u16,
|
|
|
|
outputs_count: usize,
|
|
outputs_height: u16,
|
|
|
|
scene_last: usize,
|
|
scene_count: usize,
|
|
scene_scroll: Fill<Fixed<u16, ScrollbarV>>,
|
|
scene_selected: Option<usize>,
|
|
scenes_height: u16,
|
|
|
|
track_scroll: Fill<Fixed<u16, ScrollbarH>>,
|
|
track_count: usize,
|
|
track_selected: Option<usize>,
|
|
tracks_height: u16,
|
|
|
|
show_debug_info: bool,
|
|
}
|
|
|
|
impl<'a> Content<TuiOut> for ArrangerView<'a> {
|
|
fn content (&self) -> impl Render<TuiOut> {
|
|
let ins = |x|Bsp::n(self.inputs(), x);
|
|
let tracks = |x|Bsp::s(self.tracks(), x);
|
|
let devices = |x|Bsp::s(self.devices(), x);
|
|
let outs = |x|Bsp::s(self.outputs(), x);
|
|
let bg = |x|Tui::bg(Reset, x);
|
|
//let track_scroll = |x|Bsp::s(&self.track_scroll, x);
|
|
//let scene_scroll = |x|Bsp::e(&self.scene_scroll, x);
|
|
outs(tracks(devices(ins(bg(self.scenes())))))
|
|
}
|
|
}
|
|
|
|
impl<'a> ArrangerView<'a> {
|
|
pub fn new (app: &'a App) -> Self {
|
|
Self {
|
|
app,
|
|
is_editing: app.is_editing(),
|
|
|
|
width: app.w(),
|
|
width_mid: app.w_tracks_area(),
|
|
width_side: app.w_sidebar(),
|
|
|
|
inputs_height: app.h_inputs(),
|
|
inputs_count: app.midi_ins.len(),
|
|
|
|
outputs_height: app.h_outputs(),
|
|
outputs_count: app.midi_outs.len(),
|
|
|
|
scenes_height: app.h_scenes_area(),
|
|
scene_selected: app.selected().scene(),
|
|
scene_count: app.scenes.len(),
|
|
scene_last: app.scenes.len().saturating_sub(1),
|
|
scene_scroll: Fill::y(Fixed::x(1, ScrollbarV {
|
|
offset: app.scene_scroll,
|
|
length: app.h_scenes_area() as usize,
|
|
total: app.h_scenes() as usize,
|
|
})),
|
|
|
|
tracks_height: app.h_tracks_area(),
|
|
track_count: app.tracks.len(),
|
|
track_selected: app.selected().track(),
|
|
track_scroll: Fill::x(Fixed::y(1, ScrollbarH {
|
|
offset: app.track_scroll,
|
|
length: app.h_tracks_area() as usize,
|
|
total: app.h_scenes() as usize,
|
|
})),
|
|
|
|
show_debug_info: false
|
|
}
|
|
}
|
|
|
|
/// Render input matrix.
|
|
pub(crate) fn inputs (&'a self) -> impl Content<TuiOut> + 'a {
|
|
Tui::bg(Reset, Bsp::s(
|
|
self.input_intos(),
|
|
Bsp::s(self.input_routes(), self.input_ports()),
|
|
))
|
|
}
|
|
|
|
/// Render device switches.
|
|
pub(crate) fn devices (&'a self) -> impl Content<TuiOut> + 'a {
|
|
let Self { width_side, width_mid, track_count, track_selected, is_editing, .. } = self;
|
|
Tryptich::top(1)
|
|
.left(*width_side, button_3("d", "devices", format!("{}", 0), *is_editing))
|
|
.right(*width_side, button_2("D", "add device", *is_editing))
|
|
.middle(*width_mid, per_track_top(*width_mid, ||self.tracks_with_sizes_scrolled(),
|
|
move|index, track|{
|
|
let bg = if *track_selected == Some(index) {
|
|
track.color.light
|
|
} else {
|
|
track.color.base
|
|
};
|
|
let fg = Tui::g(224);
|
|
track.devices.get(0).map(|device|wrap(bg.rgb, fg, device.name()))
|
|
}))
|
|
}
|
|
|
|
/// Render track headers
|
|
pub(crate) fn tracks (&'a self) -> impl Content<TuiOut> + 'a {
|
|
let Self { width_side, width_mid, track_count, track_selected, is_editing, .. } = self;
|
|
Tryptich::center(3)
|
|
.left(*width_side, button_3("t", "track", format!("{}", *track_count), *is_editing))
|
|
.right(*width_side, button_2("T", "add track", *is_editing))
|
|
.middle(*width_mid, per_track(*width_mid, ||self.tracks_with_sizes_scrolled(),
|
|
|index, track|wrap(
|
|
if *track_selected == Some(index) {
|
|
track.color.light
|
|
} else {
|
|
track.color.base
|
|
}.rgb,
|
|
track.color.lightest.rgb,
|
|
Tui::bold(true, Fill::xy(Align::nw(&track.name)))
|
|
)))
|
|
}
|
|
|
|
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.app.inputs_with_sizes()))
|
|
.middle(self.width_mid,
|
|
per_track_top(self.width_mid, ||self.tracks_with_sizes_scrolled(),
|
|
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 {
|
|
Tryptich::top(1)
|
|
.left(self.width_side,
|
|
button_3("i", "midi ins", format!("{}", self.inputs_count), self.is_editing))
|
|
.right(self.width_side,
|
|
button_2("I", "add midi in", self.is_editing))
|
|
.middle(self.width_mid,
|
|
per_track_top(
|
|
self.width_mid,
|
|
||self.tracks_with_sizes_scrolled(),
|
|
move|t, track|{
|
|
let rec = track.sequencer.recording;
|
|
let mon = track.sequencer.monitoring;
|
|
let rec = if rec { White } else { track.color.darkest.rgb };
|
|
let mon = if mon { White } else { track.color.darkest.rgb };
|
|
let bg = if self.track_selected == Some(t) {
|
|
track.color.light.rgb
|
|
} else {
|
|
track.color.base.rgb
|
|
};
|
|
//let bg2 = if t > 0 { track.color.base.rgb } else { Reset };
|
|
wrap(bg, Tui::g(224), Tui::bold(true, Fill::x(Bsp::e(
|
|
Tui::fg_bg(rec, bg, "Rec "),
|
|
Tui::fg_bg(mon, bg, "Mon "),
|
|
))))
|
|
}))
|
|
}
|
|
|
|
fn input_intos (&'a self) -> impl Content<TuiOut> + 'a {
|
|
Tryptich::top(2)
|
|
.left(self.width_side,
|
|
Bsp::s(Align::e("Input:"), Align::e("Into clip:")))
|
|
.middle(self.width_mid,
|
|
per_track_top(
|
|
self.width_mid,
|
|
||self.tracks_with_sizes_scrolled(),
|
|
|_, _|Tui::bg(Reset, Align::c(Bsp::s(OctaveVertical::default(), " ------ ")))))
|
|
}
|
|
|
|
/// Render scenes with clips
|
|
pub(crate) fn scenes (&'a self) -> impl Content<TuiOut> + 'a {
|
|
|
|
let Self {
|
|
width, width_side, width_mid,
|
|
scenes_height, scene_last, scene_selected,
|
|
track_selected, is_editing, app: App { editor, .. }, ..
|
|
} = self;
|
|
|
|
let scene_headers = Map::new(||self.scenes_with_scene_colors(),
|
|
move|(s, scene, y1, y2, previous): SceneWithColor, _|{
|
|
let height = (1 + y2 - y1) as u16;
|
|
let name = Some(scene.name.clone());
|
|
let content = Fill::x(Align::w(Tui::bold(true, Bsp::e(" ⯈ ", name))));
|
|
let same_track = true;
|
|
let selected = same_track && *scene_selected == Some(s);
|
|
let neighbor = same_track && s > 0 && *scene_selected == Some(s - 1);
|
|
let is_last = *scene_last == s;
|
|
let theme = scene.color;
|
|
let fg = theme.lightest.rgb;
|
|
let bg = if selected { theme.light } else { theme.base }.rgb;
|
|
let hi = if let Some(previous) = previous {
|
|
if neighbor {
|
|
previous.light.rgb
|
|
} else {
|
|
previous.base.rgb
|
|
}
|
|
} else {
|
|
Reset
|
|
};
|
|
let lo = if is_last {
|
|
Reset
|
|
} else if selected {
|
|
theme.light.rgb
|
|
} else {
|
|
theme.base.rgb
|
|
};
|
|
Fill::x(map_south(y1 as u16, height, Fixed::y(height, Phat {
|
|
width: 0, height: 0, content, colors: [fg, bg, hi, lo]
|
|
})))
|
|
});
|
|
|
|
let scene_track_clips = per_track(*width_mid, ||self.tracks_with_sizes_scrolled(),
|
|
move|track_index, track|Map::new(move||self.scenes_with_track_colors(track_index),
|
|
move|(s, scene, y1, y2, previous): SceneWithColor<'a>, _|{
|
|
let (name, theme) = if let Some(clip) = &scene.clips[track_index] {
|
|
let clip = clip.read().unwrap();
|
|
(Some(clip.name.clone()), clip.color)
|
|
} else {
|
|
(None, ItemTheme::G[32])
|
|
};
|
|
let height = (1 + y2 - y1) as u16;
|
|
let content = Fill::x(Align::w(Tui::bold(true, Bsp::e(" ⏹ ", name))));
|
|
let same_track = *track_selected == Some(track_index);
|
|
let selected = same_track && *scene_selected == Some(s);
|
|
let neighbor = same_track && s > 0 && *scene_selected == Some(s - 1);
|
|
let is_last = *scene_last == s;
|
|
let fg = theme.lightest.rgb;
|
|
let bg = if selected { theme.light } else { theme.base }.rgb;
|
|
let hi = if let Some(previous) = previous {
|
|
if neighbor {
|
|
previous.light.rgb
|
|
} else {
|
|
previous.base.rgb
|
|
}
|
|
} else {
|
|
Reset
|
|
};
|
|
let lo = if is_last {
|
|
Reset
|
|
} else if selected {
|
|
theme.light.rgb
|
|
} else {
|
|
theme.base.rgb
|
|
};
|
|
map_south(y1 as u16, height, Bsp::b(Fixed::y(height, Phat {
|
|
width: 0, height: 0, content, colors: [fg, bg, hi, lo]
|
|
}), When(
|
|
*is_editing && same_track && *scene_selected == Some(s),
|
|
editor
|
|
)))
|
|
}));
|
|
|
|
Tryptich::center(*scenes_height)
|
|
.left(*width_side, scene_headers)
|
|
.middle(*width_mid, scene_track_clips)
|
|
}
|
|
|
|
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 scenes_with_scene_colors (&self)
|
|
-> impl ScenesColors<'_>
|
|
{
|
|
self.app.scenes_with_sizes(self.is_editing, App::H_SCENE, App::H_EDITOR).map_while(
|
|
move|(s, scene, y1, y2)|if y2 as u16 > self.scenes_height {
|
|
None
|
|
} else {
|
|
Some((s, scene, y1, y2, if s == 0 {
|
|
None
|
|
} else {
|
|
Some(self.app.scenes()[s-1].color)
|
|
}))
|
|
})
|
|
}
|
|
|
|
pub(crate) fn scenes_with_track_colors (&self, track: usize)
|
|
-> impl ScenesColors<'_>
|
|
{
|
|
self.app.scenes_with_sizes(self.is_editing, App::H_SCENE, App::H_EDITOR).map_while(
|
|
move|(s, scene, y1, y2)|if y2 as u16 > self.scenes_height {
|
|
None
|
|
} else {
|
|
Some((s, scene, y1, y2, if s == 0 {
|
|
None
|
|
} else {
|
|
Some(self.app.scenes[s-1].clips[track].as_ref()
|
|
.map(|c|c.read().unwrap().color)
|
|
.unwrap_or(ItemTheme::G[32]))
|
|
}))
|
|
}
|
|
)
|
|
}
|
|
|
|
}
|
|
|
|
/// Iterator over scenes with their sizes and colors.
|
|
pub(crate) trait ScenesColors<'a> =
|
|
Iterator<Item=SceneWithColor<'a>>;
|
|
|
|
/// A scene with size and color.
|
|
pub(crate) type SceneWithColor<'a> =
|
|
(usize, &'a Scene, usize, usize, Option<ItemTheme>);
|
|
|
|
/// Define a type alias for iterators of sized items (columns).
|
|
macro_rules! def_sizes_iter {
|
|
($Type:ident => $($Item:ty),+) => {
|
|
pub(crate) trait $Type<'a> =
|
|
Iterator<Item=(usize, $(&'a $Item,)+ usize, usize)> + Send + Sync + 'a;
|
|
}
|
|
}
|
|
|
|
def_sizes_iter!(ScenesSizes => Scene);
|
|
|
|
def_sizes_iter!(TracksSizes => Track);
|
|
|
|
def_sizes_iter!(InputsSizes => JackMidiIn);
|
|
|
|
def_sizes_iter!(OutputsSizes => JackMidiOut);
|
|
|
|
def_sizes_iter!(PortsSizes => Arc<str>, [PortConnect]);
|
|
|
|
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)))
|
|
}
|
|
|
|
pub(crate) 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::g(0), Tui::orange(), Bsp::e(
|
|
Tui::fg_bg(Tui::orange(), Reset, "▐"),
|
|
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(crate) 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::g(0), Tui::orange(),
|
|
Bsp::e(Tui::fg_bg(Tui::orange(), Reset, "▐"), 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(crate) fn heading <'a> (
|
|
key: &'a str,
|
|
label: &'a str,
|
|
count: usize,
|
|
content: impl Content<TuiOut> + Send + Sync + 'a,
|
|
editing: bool,
|
|
) -> impl Content<TuiOut> + 'a {
|
|
let count = format!("{count}");
|
|
Fill::xy(Align::w(Bsp::s(Fill::x(Align::w(button_3(key, label, count, editing))), content)))
|
|
}
|
|
|
|
pub(crate) fn io_ports <'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 [PortConnect], 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))))),
|
|
Map::new(||connections.iter(), move|connect: &'a PortConnect, 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 [PortConnect], 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|connect, index|map_south(index as u16, 1,
|
|
Fill::x(Align::w(Tui::bold(false, wrap(bg, fg, Fill::x(""))))))))))
|
|
}
|
|
|
|
pub(crate) fn per_track_top <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
|
|
width: u16,
|
|
tracks: impl Fn() -> U + Send + Sync + 'a,
|
|
callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
|
|
) -> impl Content<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;
|
|
map_east(x1 as u16, width, Fixed::x(width, Tui::fg_bg(
|
|
track.color.lightest.rgb,
|
|
track.color.base.rgb,
|
|
callback(index, track))))})))
|
|
}
|
|
|
|
pub(crate) fn per_track <'a, T: Content<TuiOut> + 'a, U: TracksSizes<'a>> (
|
|
width: u16,
|
|
tracks: impl Fn() -> U + Send + Sync + 'a,
|
|
callback: impl Fn(usize, &'a Track)->T + Send + Sync + 'a
|
|
) -> impl Content<TuiOut> + 'a {
|
|
per_track_top(
|
|
width,
|
|
tracks,
|
|
move|index, track|Fill::y(Align::y(callback(index, track)))
|
|
)
|
|
}
|
|
|
|
/// Clear a pre-allocated buffer, then write into it.
|
|
#[macro_export] macro_rules! rewrite {
|
|
($buf:ident, $($rest:tt)*) => { |$buf,_,_|{ $buf.clear(); write!($buf, $($rest)*) } }
|
|
}
|
|
|
|
#[derive(Debug, Default)] pub(crate) struct ViewMemo<T, U> {
|
|
pub(crate) value: T,
|
|
pub(crate) view: Arc<RwLock<U>>
|
|
}
|
|
|
|
impl<T: PartialEq, U> ViewMemo<T, U> {
|
|
fn new (value: T, view: U) -> Self {
|
|
Self { value, view: Arc::new(view.into()) }
|
|
}
|
|
pub(crate) fn update <R> (
|
|
&mut self,
|
|
newval: T,
|
|
render: impl Fn(&mut U, &T, &T)->R
|
|
) -> Option<R> {
|
|
if newval != self.value {
|
|
let result = render(&mut*self.view.write().unwrap(), &newval, &self.value);
|
|
self.value = newval;
|
|
return Some(result);
|
|
}
|
|
None
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)] pub struct ViewCache {
|
|
pub(crate) sr: ViewMemo<Option<(bool, f64)>, String>,
|
|
pub(crate) buf: ViewMemo<Option<f64>, String>,
|
|
pub(crate) lat: ViewMemo<Option<f64>, String>,
|
|
pub(crate) bpm: ViewMemo<Option<f64>, String>,
|
|
pub(crate) beat: ViewMemo<Option<f64>, String>,
|
|
pub(crate) time: ViewMemo<Option<f64>, String>,
|
|
pub(crate) scns: ViewMemo<Option<(usize, usize)>, String>,
|
|
pub(crate) trks: ViewMemo<Option<(usize, usize)>, String>,
|
|
pub(crate) stop: Arc<str>,
|
|
pub(crate) edit: Arc<str>,
|
|
}
|
|
|
|
impl Default for ViewCache {
|
|
fn default () -> Self {
|
|
let mut beat = String::with_capacity(16);
|
|
write!(beat, "{}", Self::BEAT_EMPTY);
|
|
let mut time = String::with_capacity(16);
|
|
write!(time, "{}", Self::TIME_EMPTY);
|
|
let mut bpm = String::with_capacity(16);
|
|
write!(bpm, "{}", Self::BPM_EMPTY);
|
|
Self {
|
|
beat: ViewMemo::new(None, beat),
|
|
time: ViewMemo::new(None, time),
|
|
bpm: ViewMemo::new(None, bpm),
|
|
sr: ViewMemo::new(None, String::with_capacity(16)),
|
|
buf: ViewMemo::new(None, String::with_capacity(16)),
|
|
lat: ViewMemo::new(None, String::with_capacity(16)),
|
|
scns: ViewMemo::new(None, String::with_capacity(16)),
|
|
trks: ViewMemo::new(None, String::with_capacity(16)),
|
|
stop: "⏹".into(),
|
|
edit: "edit".into(),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ViewCache {
|
|
pub const BEAT_EMPTY: &'static str = "-.-.--";
|
|
pub const TIME_EMPTY: &'static str = "-.---s";
|
|
pub const BPM_EMPTY: &'static str = "---.---";
|
|
|
|
pub fn track_counter (cache: &Arc<RwLock<Self>>, track: usize, tracks: usize)
|
|
-> Arc<RwLock<String>>
|
|
{
|
|
let data = (track, tracks);
|
|
cache.write().unwrap().trks.update(Some(data), rewrite!(buf, "{}/{}", data.0, data.1));
|
|
cache.read().unwrap().trks.view.clone()
|
|
}
|
|
|
|
pub fn scene_add (cache: &Arc<RwLock<Self>>, scene: usize, scenes: usize, is_editing: bool)
|
|
-> impl Content<TuiOut>
|
|
{
|
|
let data = (scene, scenes);
|
|
cache.write().unwrap().scns.update(Some(data), rewrite!(buf, "({}/{})", data.0, data.1));
|
|
button_3("S", "add scene", cache.read().unwrap().scns.view.clone(), is_editing)
|
|
}
|
|
|
|
pub fn update_clock (cache: &Arc<RwLock<Self>>, clock: &Clock, compact: bool) {
|
|
let rate = clock.timebase.sr.get();
|
|
let chunk = clock.chunk.load(Relaxed) as f64;
|
|
let lat = chunk / rate * 1000.;
|
|
let delta = |start: &Moment|clock.global.usec.get() - start.usec.get();
|
|
let mut cache = cache.write().unwrap();
|
|
cache.buf.update(Some(chunk), rewrite!(buf, "{chunk}"));
|
|
cache.lat.update(Some(lat), rewrite!(buf, "{lat:.1}ms"));
|
|
cache.sr.update(Some((compact, rate)), |buf,_,_|{
|
|
buf.clear();
|
|
if compact {
|
|
write!(buf, "{:.1}kHz", rate / 1000.)
|
|
} else {
|
|
write!(buf, "{:.0}Hz", rate)
|
|
}
|
|
});
|
|
if let Some(now) = clock.started.read().unwrap().as_ref().map(delta) {
|
|
let pulse = clock.timebase.usecs_to_pulse(now);
|
|
let time = now/1000000.;
|
|
let bpm = clock.timebase.bpm.get();
|
|
cache.beat.update(Some(pulse), |buf, _, _|{
|
|
buf.clear();
|
|
clock.timebase.format_beats_1_to(buf, pulse)
|
|
});
|
|
cache.time.update(Some(time), rewrite!(buf, "{:.3}s", time));
|
|
cache.bpm.update(Some(bpm), rewrite!(buf, "{:.3}", bpm));
|
|
} else {
|
|
cache.beat.update(None, rewrite!(buf, "{}", ViewCache::BEAT_EMPTY));
|
|
cache.time.update(None, rewrite!(buf, "{}", ViewCache::TIME_EMPTY));
|
|
cache.bpm.update(None, rewrite!(buf, "{}", ViewCache::BPM_EMPTY));
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct PoolView<'a>(pub bool, pub &'a MidiPool);
|
|
|
|
content!(TuiOut: |self: PoolView<'a>| {
|
|
let Self(compact, model) = self;
|
|
let MidiPool { clips, .. } = self.1;
|
|
//let color = self.1.clip().map(|c|c.read().unwrap().color).unwrap_or_else(||Tui::g(32).into());
|
|
let on_bg = |x|x;//Bsp::b(Repeat(" "), Tui::bg(color.darkest.rgb, x));
|
|
let border = |x|x;//Outer(Style::default().fg(color.dark.rgb).bg(color.darkest.rgb)).enclose(x);
|
|
let iter = | |model.clips().clone().into_iter();
|
|
let height = clips.read().unwrap().len() as u16;
|
|
Tui::bg(Reset, Fixed::y(height, on_bg(border(Map::new(iter, move|clip: Arc<RwLock<MidiClip>>, i|{
|
|
let item_height = 1;
|
|
let item_offset = i as u16 * item_height;
|
|
let selected = i == model.clip_index();
|
|
let MidiClip { ref name, color, length, .. } = *clip.read().unwrap();
|
|
let bg = if selected { color.light.rgb } else { color.base.rgb };
|
|
let fg = color.lightest.rgb;
|
|
let name = if *compact { format!(" {i:>3}") } else { format!(" {i:>3} {name}") };
|
|
let length = if *compact { String::default() } else { format!("{length} ") };
|
|
Fixed::y(1, map_south(item_offset, item_height, Tui::bg(bg, lay!(
|
|
Fill::x(Align::w(Tui::fg(fg, Tui::bold(selected, name)))),
|
|
Fill::x(Align::e(Tui::fg(fg, Tui::bold(selected, length)))),
|
|
Fill::x(Align::w(When::new(selected, Tui::bold(true, Tui::fg(Tui::g(255), "▶"))))),
|
|
Fill::x(Align::e(When::new(selected, Tui::bold(true, Tui::fg(Tui::g(255), "◀"))))),
|
|
))))
|
|
})))))
|
|
});
|
|
|
|
content!(TuiOut: |self: ClipLength| {
|
|
use ClipLengthFocus::*;
|
|
let bars = ||self.bars_string();
|
|
let beats = ||self.beats_string();
|
|
let ticks = ||self.ticks_string();
|
|
match self.focus {
|
|
None => row!(" ", bars(), ".", beats(), ".", ticks()),
|
|
Some(Bar) => row!("[", bars(), "]", beats(), ".", ticks()),
|
|
Some(Beat) => row!(" ", bars(), "[", beats(), "]", ticks()),
|
|
Some(Tick) => row!(" ", bars(), ".", beats(), "[", ticks()),
|
|
}
|
|
});
|