use std::sync::Arc;
use super::{
names,
part_style::{Length, PartStyle},
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe},
seek_bar::{SeekHandler, seek_control},
theme::{Themed, current_theme},
};
use crate::{
app::theme::{OpacityLevel, PaletteColor, RadiusSize, Theme},
components::{self, Row, Stack},
core::Signal,
layout::{Alignment, StackAlignment, layout_kind::Justify},
node::{CursorIcon, Element, SliderPartStyle, color::Color, dimension::Dimension},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum WaveformPart {
Root,
Bars,
Bar,
Played,
Control,
}
names!(WaveformPart {
Root => "root",
Bars => "bars",
Bar => "bar",
Played => "played",
Control => "control",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum WaveformState {
Disabled,
Unheard,
Operated,
}
names!(WaveformState {
Disabled => "disabled",
Unheard => "unheard",
Operated => "operated",
});
pub type WaveformRenderer = Arc<dyn Fn(WaveformView) -> Element + Send + Sync>;
#[derive(Clone)]
pub struct Waveform {
progress: f64,
bound: Option<Signal<f32>>,
operated: bool,
peaks: Vec<f32>,
unheard: bool,
step: f64,
label: Arc<str>,
disabled: bool,
on_change: Vec<SeekHandler>,
on_change_end: Vec<SeekHandler>,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl Waveform {
pub fn at(progress: impl Into<f64>, peaks: &[f32]) -> Self {
Self {
progress: progress.into(),
bound: None,
operated: false,
peaks: peaks.to_vec(),
unheard: false,
step: 0.05,
label: super::current_locale().media.seek.clone(),
disabled: false,
on_change: Vec::new(),
on_change_end: Vec::new(),
states: Vec::new(),
rules: Recipe::new(),
forced: None,
id: None,
key: None,
}
}
pub fn new(progress: Signal<f32>, peaks: &[f32]) -> Self {
let mut wave = Self::at(0.0, peaks);
wave.bound = Some(progress);
wave.operated = true;
wave
}
pub fn controlled(progress: impl Into<f64>, peaks: &[f32], on_change: impl Fn(f64) + Send + Sync + 'static) -> Self {
let mut wave = Self::at(progress, peaks).on_change(on_change);
wave.operated = true;
wave
}
pub fn unheard(mut self, unheard: bool) -> Self {
self.unheard = unheard;
self
}
pub fn step(mut self, step: impl Into<f64>) -> Self {
self.step = step.into();
self
}
pub fn label(mut self, label: &str) -> Self {
self.label = Arc::from(label);
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
pub fn on_change(mut self, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.on_change.push(Arc::new(handler));
self
}
pub fn on_change_end(mut self, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.on_change_end.push(Arc::new(handler));
self
}
pub fn state(mut self, state: impl Into<Name>, on: bool) -> Self {
let state = state.into();
self.states.retain(|held| *held != state);
if on {
self.states.push(state);
}
self
}
pub fn style(mut self, part: impl Into<Name>, style: impl FnOnce(PartStyle) -> PartStyle) -> Self {
self.rules = self.rules.base(part, style);
self
}
pub fn rules(mut self, rules: &Recipe) -> Self {
self.rules = self.rules.extend(rules);
self
}
pub fn force(mut self, interaction: Option<Interaction>) -> Self {
self.forced = interaction;
self
}
pub fn id(mut self, id: impl Into<Arc<str>>) -> Self {
self.id = Some(id.into());
self
}
pub fn key(mut self, key: impl Into<Arc<str>>) -> Self {
self.key = Some(key.into());
self
}
pub fn build(self, theme: &Theme) -> Element {
let progress = match &self.bound {
Some(bound) => f64::from(bound.get()),
None => self.progress,
};
let progress = if progress.is_finite() {
progress.clamp(0.0, 1.0)
} else {
0.0
};
let case = Case {
variant: None,
size: None,
density: None,
breakpoint: super::current_breakpoint(),
states: self.states.clone(),
}
.state(WaveformState::Disabled, self.disabled)
.state(WaveformState::Unheard, self.unheard)
.state(WaveformState::Operated, self.operated);
let view = WaveformView {
progress,
peaks: self.peaks,
unheard: self.unheard,
operated: self.operated,
step: self.step,
label: self.label,
disabled: self.disabled,
recipe: theme
.resolve::<Waveform>(&case, Some(&self.rules))
.owned_by(self.id.as_ref()),
bound: self.bound,
on_change: self.on_change,
on_change_end: self.on_change_end,
forced: self.forced,
id: self.id,
key: self.key,
};
match theme.renderer::<Waveform>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
}
impl From<Waveform> for Element {
fn from(wave: Waveform) -> Self {
wave.build(¤t_theme())
}
}
pub struct WaveformView {
pub progress: f64,
pub peaks: Vec<f32>,
pub unheard: bool,
pub operated: bool,
pub step: f64,
pub label: Arc<str>,
pub disabled: bool,
pub recipe: ResolvedRecipe,
bound: Option<Signal<f32>>,
on_change: Vec<SeekHandler>,
on_change_end: Vec<SeekHandler>,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl WaveformView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part).forced(self.forced.filter(|_| self.operated))
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
fn px(&self, length: Option<Length>) -> Option<f32> {
match length?.resolve(self.theme())? {
Dimension::Px(px) => Some(px),
_ => None,
}
}
pub fn played(&self) -> usize {
if self.unheard {
0
} else {
(self.progress * self.peaks.len() as f64).round() as usize
}
}
pub fn width(&self) -> f32 {
let bar = self.px(self.part(WaveformPart::Bar).rest().width).unwrap_or(3.0);
let gap = self
.part(WaveformPart::Bars)
.rest()
.gap
.map_or(2.0, |gap| gap.resolve(&self.theme().spacing(), 0.0));
let count = self.peaks.len() as f32;
(count * bar + (count - 1.0).max(0.0) * gap).max(0.0)
}
pub fn bars(&self) -> Row {
let tallest = self.px(self.part(WaveformPart::Root).rest().height).unwrap_or(24.0);
let played = self.played();
let (bar, played_bar) = (self.part(WaveformPart::Bar), self.part(WaveformPart::Played));
self.peaks.iter().enumerate().fold(
Row::new()
.part(&self.part(WaveformPart::Bars))
.spacing(0.0)
.width(Dimension::Pct(100.0))
.justify(Justify::SpaceBetween)
.align_items(Alignment::Center)
.describe("a11y_hidden", "true"),
|row, (index, peak)| {
let part = if index < played { &played_bar } else { &bar };
let peak = if peak.is_finite() { peak.clamp(0.0, 1.0) } else { 0.0 };
row.child(Row::new().part(part).flex_shrink(0.0).height(peak * tallest))
},
)
}
pub fn control(&self) -> Option<components::Slider> {
if !self.operated {
return None;
}
let height = self.px(self.part(WaveformPart::Root).rest().height).unwrap_or(24.0);
let clear = || SliderPartStyle::new().background(Color::new(0, 0, 0, 0));
let mut slider = seek_control(
self.progress,
1.0,
self.step,
self.bound.clone(),
&self.on_change,
&self.on_change_end,
self.disabled,
)
.part(&self.part(WaveformPart::Control))
.width(Dimension::Pct(100.0))
.height(height)
.track_style(clear().height(height))
.thumb_style(clear().size(0.0, 0.0))
.describe("a11y_role", "slider")
.describe("a11y_name", self.label.clone())
.describe("a11y_value", format!("{}%", (self.progress * 100.0).round()));
if let Some(id) = &self.id {
slider = slider.id(id.clone());
}
Some(slider)
}
pub fn render(self) -> Element {
let mut root = Stack::new()
.stack_align(StackAlignment::Center)
.part(&self.part(WaveformPart::Root))
.width(self.width())
.max_width(Dimension::Pct(100.0))
.min_width(0.0)
.flex_shrink(1.0)
.overflow_visible()
.child(self.bars());
if let Some(control) = self.control() {
root = root.child(control);
} else if let Some(id) = &self.id {
root = root.id(id.clone());
}
if let Some(key) = &self.key {
root = root.key(key.clone());
}
root.into()
}
}
impl crate::ui::Styled for Waveform {
type Component = Self;
fn rules(self, rules: &crate::ui::Recipe) -> Self {
Self::rules(self, rules)
}
fn state(self, state: impl Into<crate::ui::Name>, on: bool) -> Self {
Self::state(self, state, on)
}
}
impl Themed for Waveform {
const NAME: &'static str = "waveform";
type Renderer = WaveformRenderer;
fn parts() -> crate::ui::Declared {
WaveformPart::declared()
}
fn states() -> crate::ui::Declared {
WaveformState::declared()
}
fn recipe() -> Recipe {
use PaletteColor::*;
use WaveformPart::{Bar, Bars, Control, Played, Root};
Recipe::new()
.base(Root, |s| s.height(24.0))
.base(Bars, |s| s.gap(2.0))
.base(Bar, |s| {
s.width(3.0).min_height(3.0).radius(RadiusSize::Full).background(Input)
})
.base(Played, |s| {
s.width(3.0)
.min_height(3.0)
.radius(RadiusSize::Full)
.background(Primary)
})
.base(Control, |s| s.radius(RadiusSize::Sm).cursor(CursorIcon::Pointer))
.focus_visible(Control, |s| s.focus_ring())
.state(WaveformState::Disabled, Root, |s| s.opacity(OpacityLevel::Disabled))
.state(WaveformState::Disabled, Control, |s| s.cursor(CursorIcon::Default))
}
}