use std::sync::Arc;
use super::{
MEDIA_RATES, Menu, MenuItem, MenuItemPart, MenuPart, media_rate_text, names,
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe},
theme::{Themed, current_theme},
};
use crate::{
app::{
ctx::{CollisionStrategy, Placement},
theme::Theme,
},
core::{ElementRef, Signal},
node::{Element, SpacingValue},
};
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum MediaSpeedMenuPart {
Panel,
Label,
Item,
ItemLabel,
Check,
}
names!(MediaSpeedMenuPart {
Panel => "panel",
Label => "label",
Item => "item",
ItemLabel => "item_label",
Check => "check",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum MediaSpeedMenuState {
Inline,
}
names!(MediaSpeedMenuState {
Inline => "inline",
});
pub type MediaSpeedMenuRenderer = Arc<dyn Fn(MediaSpeedMenuView) -> Element + Send + Sync>;
pub struct MediaSpeedMenu {
open: Signal<bool>,
anchor: ElementRef,
rate: f32,
rates: Vec<f32>,
heading: Arc<str>,
label: Option<Arc<str>>,
on_change: Vec<Arc<dyn Fn(f64) + Send + Sync>>,
on_dismiss: Vec<Arc<dyn Fn() + Send + Sync>>,
on_open_change: Vec<Arc<dyn Fn(bool) + Send + Sync>>,
placement: Option<Placement>,
offset: Option<SpacingValue>,
collision: Option<CollisionStrategy>,
inline: bool,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl MediaSpeedMenu {
pub fn new(open: Signal<bool>, anchor: impl Into<ElementRef>, rate: f32) -> Self {
Self {
open,
anchor: anchor.into(),
rate,
rates: MEDIA_RATES.to_vec(),
heading: super::current_locale().media.playback_speed.clone(),
label: None,
on_change: Vec::new(),
on_dismiss: Vec::new(),
on_open_change: Vec::new(),
placement: None,
offset: None,
collision: None,
inline: false,
states: Vec::new(),
rules: Recipe::new(),
forced: None,
id: None,
key: None,
}
}
pub fn rates(mut self, rates: &[f32]) -> Self {
self.rates = rates.to_vec();
self
}
pub fn heading_text(mut self, heading: &str) -> Self {
self.heading = Arc::from(heading);
self
}
pub fn label(mut self, label: &str) -> Self {
self.label = Some(Arc::from(label));
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_dismiss(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.on_dismiss.push(Arc::new(handler));
self
}
pub fn on_open_change(mut self, handler: impl Fn(bool) + Send + Sync + 'static) -> Self {
self.on_open_change.push(Arc::new(handler));
self
}
pub fn placement(mut self, placement: Placement) -> Self {
self.placement = Some(placement);
self
}
pub fn offset(mut self, offset: impl Into<SpacingValue>) -> Self {
self.offset = Some(offset.into());
self
}
pub fn collision(mut self, collision: CollisionStrategy) -> Self {
self.collision = Some(collision);
self
}
pub fn inline(mut self, inline: bool) -> Self {
self.inline = inline;
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(super::PartStyle) -> super::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 case = Case {
variant: None,
size: None,
density: None,
breakpoint: super::current_breakpoint(),
states: self.states.clone(),
}
.state(MediaSpeedMenuState::Inline, self.inline);
let view = MediaSpeedMenuView {
label: self.label.unwrap_or_else(|| self.heading.clone()),
heading: self.heading,
rate: self.rate,
rates: self.rates,
inline: self.inline,
recipe: theme
.resolve::<MediaSpeedMenu>(&case, Some(&self.rules))
.owned_by(self.id.as_ref()),
open: self.open,
anchor: self.anchor,
on_change: Arc::new(self.on_change),
on_dismiss: self.on_dismiss,
on_open_change: self.on_open_change,
placement: self.placement,
offset: self.offset,
collision: self.collision,
forced: self.forced,
id: self.id,
key: self.key,
};
match theme.renderer::<MediaSpeedMenu>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
}
impl From<MediaSpeedMenu> for Element {
fn from(menu: MediaSpeedMenu) -> Self {
menu.build(¤t_theme())
}
}
pub struct MediaSpeedMenuView {
pub heading: Arc<str>,
pub label: Arc<str>,
pub rate: f32,
pub rates: Vec<f32>,
pub inline: bool,
pub recipe: ResolvedRecipe,
open: Signal<bool>,
anchor: ElementRef,
on_change: Arc<Vec<Arc<dyn Fn(f64) + Send + Sync>>>,
on_dismiss: Vec<Arc<dyn Fn() + Send + Sync>>,
on_open_change: Vec<Arc<dyn Fn(bool) + Send + Sync>>,
placement: Option<Placement>,
offset: Option<SpacingValue>,
collision: Option<CollisionStrategy>,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl MediaSpeedMenuView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
pub fn is_current(&self, rate: f32) -> bool {
(rate - self.rate).abs() < f32::EPSILON
}
pub fn item(&self, rate: f32) -> MenuItem {
let rules = self
.recipe
.rules_for(MediaSpeedMenuPart::Item, MenuItemPart::Root)
.extend(
&self
.recipe
.rules_for(MediaSpeedMenuPart::ItemLabel, MenuItemPart::Label),
)
.extend(&self.recipe.rules_for(MediaSpeedMenuPart::Check, MenuItemPart::Check));
let (current, handlers) = (self.is_current(rate), self.on_change.clone());
let mut item = MenuItem::new(&media_rate_text(rate))
.checked(current)
.key(format!("rate-{rate}"))
.named_by(&self.recipe, MediaSpeedMenuPart::Item)
.rules(&rules)
.on_select(move || {
if !current {
for handler in handlers.iter() {
handler(f64::from(rate));
}
}
});
if current {
item = item.force(self.forced);
}
item
}
pub fn menu(&self) -> Menu {
let rules = self
.recipe
.rules_for(MediaSpeedMenuPart::Panel, MenuPart::Panel)
.extend(&self.recipe.rules_for(MediaSpeedMenuPart::Label, MenuPart::Label));
let mut menu = Menu::new(self.open.clone(), self.anchor.clone())
.label(&self.label)
.heading(&self.heading)
.items(self.rates.iter().map(|rate| self.item(*rate)))
.inline(self.inline)
.rules(&rules);
if let Some(placement) = self.placement {
menu = menu.placement(placement);
}
if let Some(offset) = self.offset.clone() {
menu = menu.offset(offset);
}
if let Some(collision) = self.collision {
menu = menu.collision(collision);
}
for handler in &self.on_dismiss {
let handler = handler.clone();
menu = menu.on_dismiss(move || handler());
}
for handler in &self.on_open_change {
let handler = handler.clone();
menu = menu.on_open_change(move |open| handler(open));
}
if let Some(id) = &self.id {
menu = menu.id(id.clone());
}
if let Some(key) = &self.key {
menu = menu.key(key.clone());
}
menu
}
pub fn render(self) -> Element {
self.menu().build(self.theme())
}
}
impl crate::ui::Styled for MediaSpeedMenu {
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 MediaSpeedMenu {
const NAME: &'static str = "media_speed_menu";
const ROOT: &'static str = "panel";
type Renderer = MediaSpeedMenuRenderer;
fn parts() -> crate::ui::Declared {
MediaSpeedMenuPart::declared()
}
fn states() -> crate::ui::Declared {
MediaSpeedMenuState::declared()
}
fn recipe() -> Recipe {
use MediaSpeedMenuPart::Panel;
Recipe::new().base(Panel, |s| s.width(168.0).min_width(168.0).max_width(168.0))
}
}