use std::{
sync::{
Arc, Mutex,
atomic::{AtomicBool, AtomicU8, AtomicU32, Ordering},
},
time::Duration,
};
use super::{
MEDIA_RATES, MediaCaptions, MediaSpeedMenu, MediaTime, MediaTimeSize, MediaVolume, MediaVolumeSize, Menu, MenuItem,
MenuItemPart, MenuPart, PlayButton, PlayButtonSize, PlayButtonVariant, SeekBar, Tooltip, icons, media_rate_text,
media_time_text, names,
part_style::{Length, PartTransition},
recipe::{Case, Interaction, Name, Recipe, ResolvedPart, ResolvedRecipe, Selector},
shared::{fading, glyph, pressable},
theme::{Themed, current_theme},
};
use crate::{
animation::Transition,
app::{
component::Component,
ctx::{Ctx, Placement, Timeout},
events::{GesturePhase, KeyboardEvent, MouseEvent, PanEvent},
theme::{MotionDuration, MotionEasing, RadiusSize, Theme, TypographyStyle},
},
components::{Column, Modal, Root, Row, Stack},
core::{ElementRef, Signal},
layout::{
Alignment,
layout_kind::Justify,
text_style::{FontWeight, TextAlign},
},
node::{CursorIcon, Element, HitTestBehavior, color::Color, dimension::Dimension, outline::Outline},
time::Instant,
};
pub const VIDEO_PLAYER_HIDE_AFTER: Duration = Duration::from_secs(3);
pub const VIDEO_PLAYER_COMPACT_BELOW: f32 = 400.0;
pub const VIDEO_PLAYER_MINIMAL_BELOW: f32 = 280.0;
pub const VIDEO_PLAYER_VOLUME_FOLDS_BELOW: f32 = 480.0;
pub const VIDEO_PLAYER_ASPECT: f32 = 16.0 / 9.0;
pub const VIDEO_PLAYER_PICTURE_WIDTH: u32 = 400;
pub const VIDEO_PLAYER_TAP_SEEKS: f64 = 10.0;
pub const VIDEO_PLAYER_MARK_STAYS: Duration = Duration::from_millis(800);
const VIDEO_PLAYER_DROP_LEAVES: f32 = 120.0;
const VIDEO_PLAYER_THROW_LEAVES: f32 = 900.0;
pub const VIDEO_PLAYER_DOUBLE_PRESS: Duration = Duration::from_millis(500);
pub const VIDEO_PLAYER_SEEK_STEP: f64 = 5.0;
pub const VIDEO_PLAYER_VOLUME_STEP: f64 = 0.05;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum VideoPlayerPart {
Root,
Media,
Veil,
Overlay,
Center,
Spinner,
Error,
ErrorIcon,
Text,
Title,
Description,
Retry,
Captions,
Caption,
Chip,
ChipValue,
Controls,
Row,
Control,
ControlIcon,
Speed,
Time,
Elapsed,
Menus,
SettingsMenu,
MoreMenu,
MenuValue,
Scrim,
Top,
Heading,
Line,
Touch,
TouchIcon,
Transport,
Skip,
SkipIcon,
Disc,
DiscIcon,
Foot,
Pill,
Rail,
Mark,
MarkIcon,
MarkText,
}
names!(VideoPlayerPart {
Root => "root",
Media => "media",
Veil => "veil",
Overlay => "overlay",
Center => "center",
Spinner => "spinner",
Error => "error",
ErrorIcon => "error_icon",
Text => "text",
Title => "title",
Description => "description",
Retry => "retry",
Captions => "captions",
Caption => "caption",
Chip => "chip",
ChipValue => "chip_value",
Controls => "controls",
Row => "row",
Control => "control",
ControlIcon => "control_icon",
Speed => "speed",
Time => "time",
Elapsed => "elapsed",
Menus => "menus",
SettingsMenu => "settings_menu",
MoreMenu => "more_menu",
MenuValue => "menu_value",
Scrim => "scrim",
Top => "top",
Heading => "heading",
Line => "line",
Touch => "touch",
TouchIcon => "touch_icon",
Transport => "transport",
Skip => "skip",
SkipIcon => "skip_icon",
Disc => "disc",
DiscIcon => "disc_icon",
Foot => "foot",
Pill => "pill",
Rail => "rail",
Mark => "mark",
MarkIcon => "mark_icon",
MarkText => "mark_text",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum VideoPlayerState {
Playing,
Waiting,
Ended,
Error,
Live,
Muted,
Captions,
Fullscreen,
Poster,
Bare,
Hidden,
Narrow,
On,
Touch,
Landscape,
}
names!(VideoPlayerState {
Playing => "playing",
Waiting => "waiting",
Ended => "ended",
Error => "error",
Live => "live",
Muted => "muted",
Captions => "captions",
Fullscreen => "fullscreen",
Poster => "poster",
Bare => "bare",
Hidden => "hidden",
Narrow => "narrow",
On => "on",
Touch => "touch",
Landscape => "landscape",
});
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum VideoPlayerSize {
Sm,
Md,
#[default]
Lg,
}
names!(VideoPlayerSize {
Sm => "sm",
Md => "md",
Lg => "lg",
});
impl VideoPlayerSize {
pub fn for_width(width: f32) -> Self {
if width < VIDEO_PLAYER_MINIMAL_BELOW {
Self::Sm
} else if width < VIDEO_PLAYER_COMPACT_BELOW {
Self::Md
} else {
Self::Lg
}
}
fn of(name: Name) -> Self {
[Self::Sm, Self::Md]
.into_iter()
.find(|size| Name::from(*size) == name)
.unwrap_or(Self::Lg)
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum VideoPlayerMenu {
Settings,
Speed,
More,
}
pub type VideoPlayerRenderer = Arc<dyn Fn(VideoPlayerView) -> Element + Send + Sync>;
type Handler<T> = Arc<dyn Fn(T) + Send + Sync>;
type Action = Arc<dyn Fn() + Send + Sync>;
type Layer = Arc<Mutex<Box<dyn FnMut(&VideoPlayback) -> Element + Send>>>;
#[derive(Clone)]
pub struct VideoPlayback {
pub playing: bool,
pub waiting: bool,
pub ended: bool,
pub failed: bool,
pub opening: bool,
pub poster_shown: bool,
pub position: f64,
pub duration: Option<f64>,
pub buffered: Option<f64>,
pub volume: f64,
pub muted: bool,
pub rate: f64,
seek: Handler<f64>,
play: Handler<bool>,
mute: Handler<bool>,
}
impl VideoPlayback {
pub fn seek(&self, seconds: f64) {
(self.seek)(seconds);
}
pub fn set_playing(&self, playing: bool) {
(self.play)(playing);
}
pub fn set_muted(&self, muted: bool) {
(self.mute)(muted);
}
pub fn progress(&self) -> f64 {
match self.duration {
Some(duration) if duration > 0.0 => (self.position / duration).clamp(0.0, 1.0),
_ => 0.0,
}
}
}
impl std::fmt::Debug for VideoPlayback {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("VideoPlayback")
.field("playing", &self.playing)
.field("waiting", &self.waiting)
.field("ended", &self.ended)
.field("failed", &self.failed)
.field("opening", &self.opening)
.field("position", &self.position)
.field("duration", &self.duration)
.finish_non_exhaustive()
}
}
#[derive(Clone)]
struct Held<T: Copy> {
value: T,
handlers: Vec<Handler<T>>,
}
impl<T: Copy + Send + Sync + 'static> Held<T> {
fn new(value: T) -> Self {
Self {
value,
handlers: Vec::new(),
}
}
fn bind(&mut self, value: T, set: impl Fn(T) + Send + Sync + 'static) {
self.value = value;
self.handlers.insert(0, Arc::new(set));
}
fn hold(&mut self, value: T, handler: impl Fn(T) + Send + Sync + 'static) {
self.value = value;
self.handlers.push(Arc::new(handler));
}
fn add(&mut self, handler: impl Fn(T) + Send + Sync + 'static) {
self.handlers.push(Arc::new(handler));
}
fn teller(&self) -> impl Fn(T) + Send + Sync + Clone + 'static {
let handlers = self.handlers.clone();
move |value| {
for handler in &handlers {
handler(value);
}
}
}
}
#[derive(Clone)]
struct Words {
label: Arc<str>,
play: Arc<str>,
pause: Arc<str>,
replay: Arc<str>,
mute: Arc<str>,
unmute: Arc<str>,
volume: Arc<str>,
seek: Arc<str>,
captions: Arc<str>,
speed: Arc<str>,
speed_heading: Arc<str>,
settings: Arc<str>,
quality: Arc<str>,
picture_in_picture: Arc<str>,
in_picture: Arc<str>,
back: Arc<str>,
unplayable: Arc<str>,
fullscreen: Arc<str>,
exit_fullscreen: Arc<str>,
more: Arc<str>,
retry: Arc<str>,
rewind: Arc<str>,
forward: Arc<str>,
seconds: Arc<str>,
minimize: Arc<str>,
leave: Arc<str>,
auto: Arc<str>,
on: Arc<str>,
off: Arc<str>,
live: Arc<str>,
}
impl Words {
fn of(words: &crate::core::MediaWords) -> Self {
Self {
label: words.video_player.clone(),
play: words.play.clone(),
pause: words.pause.clone(),
replay: words.replay.clone(),
mute: words.mute.clone(),
unmute: words.unmute.clone(),
volume: words.volume.clone(),
seek: words.seek.clone(),
captions: words.captions.clone(),
speed: words.speed.clone(),
speed_heading: words.playback_speed.clone(),
settings: words.settings.clone(),
quality: words.quality.clone(),
picture_in_picture: words.picture_in_picture.clone(),
in_picture: words.in_picture.clone(),
back: words.back_to_window.clone(),
unplayable: words.unplayable_video.clone(),
fullscreen: words.fullscreen.clone(),
exit_fullscreen: words.exit_fullscreen.clone(),
more: words.more.clone(),
retry: words.try_again.clone(),
rewind: words.rewind.clone(),
forward: words.forward.clone(),
seconds: words.seconds.clone(),
minimize: words.minimize.clone(),
leave: words.back.clone(),
auto: words.auto.clone(),
on: words.on.clone(),
off: words.off.clone(),
live: words.live.clone(),
}
}
}
impl Default for Words {
fn default() -> Self {
Self::of(&super::current_locale().media)
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
pub enum VideoFullscreen {
#[default]
Window,
Screen,
App,
}
#[derive(Clone)]
pub struct VideoPlayer {
media: Option<Element>,
poster: Option<Element>,
children: Vec<Element>,
layers: Vec<Layer>,
said_source: Option<Arc<str>>,
opening: bool,
poster_until_frame: bool,
framed: Option<bool>,
controls: bool,
playing: Held<bool>,
position: Held<f64>,
on_position_change_end: Vec<Handler<f64>>,
duration: Option<f64>,
buffered: Option<f64>,
chapters: Vec<f64>,
preview: Option<Arc<dyn Fn(f64) -> Element + Send + Sync>>,
live: bool,
waiting: bool,
ended: bool,
error: Option<Arc<str>>,
error_description: Option<Arc<str>>,
locale: Option<crate::core::MediaWords>,
on_retry: Vec<Action>,
events: super::media_events::MediaEvents,
#[cfg(feature = "media")]
source: Option<crate::resources::Source>,
touch: Option<bool>,
title: Option<Arc<str>>,
description: Option<Arc<str>>,
on_back: Vec<Action>,
volume: Held<f64>,
on_volume_change_end: Vec<Handler<f64>>,
muted: Held<bool>,
rate: Held<f64>,
rates: Vec<f32>,
captions: Held<bool>,
caption_text: Option<Arc<str>>,
caption_cues: Option<MediaCaptions>,
captions_track: Option<Arc<str>>,
captions_button: bool,
settings_button: bool,
looped: bool,
qualities: Vec<Arc<str>>,
quality: Held<Option<usize>>,
fullscreen: Held<bool>,
fullscreen_fills: VideoFullscreen,
picture_in_picture: Held<bool>,
picture_in_picture_window: bool,
size: Option<Name>,
width: Option<Length>,
height: Option<Length>,
max_width: Option<Length>,
aspect: f32,
force_menu: Option<VideoPlayerMenu>,
force_controls_shown: Option<bool>,
words: Words,
states: Vec<Name>,
rules: Recipe,
forced: Option<Interaction>,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl Default for VideoPlayer {
fn default() -> Self {
Self::new()
}
}
macro_rules! held {
($field:ident, $controlled:ident, $on:ident, $ty:ty, $signal:ty, $doc:literal) => {
#[doc = concat!("Bound to `signal`: ", $doc, " What a person does sets the signal, and then the handlers are told.")]
pub fn $field(mut self, signal: Signal<$signal>) -> Self {
let value = signal.get();
self.$field.bind(value.into(), move |next: $ty| signal.set(next as $signal));
self
}
#[doc = concat!("Held by the app: ", $doc, " A press tells `handler` what it is to be, and changes nothing until the app answers.")]
pub fn $controlled(mut self, value: $ty, handler: impl Fn($ty) + Send + Sync + 'static) -> Self {
self.$field.hold(value, handler);
self
}
#[doc = concat!("Called with what a person makes it: ", $doc, " A second handler is called after the first.")]
pub fn $on(mut self, handler: impl Fn($ty) + Send + Sync + 'static) -> Self {
self.$field.add(handler);
self
}
};
}
macro_rules! words {
($($method:ident => $field:ident, $doc:literal;)*) => {
$(
#[doc = $doc]
pub fn $method(mut self, words: &str) -> Self {
self.words.$field = Arc::from(words);
self
}
)*
};
}
impl VideoPlayer {
pub fn new() -> Self {
Self {
media: None,
poster: None,
children: Vec::new(),
layers: Vec::new(),
said_source: None,
opening: false,
poster_until_frame: false,
framed: None,
controls: true,
playing: Held::new(false),
position: Held::new(0.0),
on_position_change_end: Vec::new(),
duration: None,
buffered: None,
chapters: Vec::new(),
preview: None,
live: false,
waiting: false,
ended: false,
error: None,
error_description: None,
locale: None,
on_retry: Vec::new(),
events: super::media_events::MediaEvents::default(),
#[cfg(feature = "media")]
source: None,
touch: None,
title: None,
description: None,
on_back: Vec::new(),
volume: Held::new(1.0),
on_volume_change_end: Vec::new(),
muted: Held::new(false),
rate: Held::new(1.0),
rates: MEDIA_RATES.to_vec(),
captions: Held::new(false),
caption_text: None,
caption_cues: None,
captions_track: None,
captions_button: true,
settings_button: true,
looped: false,
qualities: Vec::new(),
quality: Held::new(None),
fullscreen: Held::new(false),
fullscreen_fills: VideoFullscreen::Window,
picture_in_picture: Held::new(false),
picture_in_picture_window: true,
size: None,
width: None,
height: None,
max_width: None,
aspect: VIDEO_PLAYER_ASPECT,
force_menu: None,
force_controls_shown: None,
words: Words::default(),
states: Vec::new(),
rules: Recipe::new(),
forced: None,
id: None,
key: None,
}
}
pub fn media(mut self, media: impl Into<Element>) -> Self {
self.media = Some(media.into());
self
}
pub fn poster(mut self, poster: impl Into<Element>) -> Self {
self.poster = Some(poster.into());
self
}
pub fn poster_until_frame(mut self, until_frame: bool) -> Self {
self.poster_until_frame = until_frame;
self
}
pub fn child(mut self, child: impl Into<Element>) -> Self {
self.children.push(child.into());
self
}
pub fn children(mut self, children: impl IntoIterator<Item = impl Into<Element>>) -> Self {
self.children.extend(children.into_iter().map(Into::into));
self
}
pub fn child_with<E: Into<Element>>(mut self, mut layer: impl FnMut(&VideoPlayback) -> E + Send + 'static) -> Self {
let build: Box<dyn FnMut(&VideoPlayback) -> Element + Send> = Box::new(move |playback| layer(playback).into());
self.layers.push(Arc::new(Mutex::new(build)));
self
}
pub fn background(self, color: impl Into<crate::node::BackgroundColor>) -> Self {
let color = color.into();
self.style(VideoPlayerPart::Root, move |s| s.background(color))
}
pub fn controls(mut self, controls: bool) -> Self {
self.controls = controls;
self
}
held!(
playing,
playing_controlled,
on_playing_change,
bool,
bool,
"whether it plays."
);
pub fn position(mut self, signal: Signal<f32>) -> Self {
let value = f64::from(signal.get());
self.position.bind(value, move |next| signal.set(next as f32));
self
}
pub fn position_controlled(
mut self,
position: impl Into<f64>,
handler: impl Fn(f64) + Send + Sync + 'static,
) -> Self {
self.position.hold(position.into(), handler);
self
}
pub fn on_position_change(mut self, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.position.add(handler);
self
}
pub fn on_position_change_end(mut self, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.on_position_change_end.push(Arc::new(handler));
self
}
pub fn duration(mut self, duration: impl Into<f64>) -> Self {
self.duration = Some(duration.into());
self
}
pub fn buffered(mut self, buffered: impl Into<f64>) -> Self {
self.buffered = Some(buffered.into());
self
}
pub fn preview(mut self, preview: impl Fn(f64) -> Element + Send + Sync + 'static) -> Self {
self.preview = Some(Arc::new(preview));
self
}
pub fn chapters(mut self, starts: &[f64]) -> Self {
self.chapters = starts.to_vec();
self
}
pub fn live(mut self, live: bool) -> Self {
self.live = live;
self
}
pub fn waiting(mut self, waiting: bool) -> Self {
self.waiting = waiting;
self
}
pub fn ended(mut self, ended: bool) -> Self {
self.ended = ended;
self
}
pub fn error(mut self, title: &str) -> Self {
self.error = Some(Arc::from(title));
self
}
pub fn error_description(mut self, description: &str) -> Self {
self.error_description = Some(Arc::from(description));
self
}
pub fn on_retry(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.on_retry.push(Arc::new(handler));
self
}
pub fn on_load(mut self, handler: impl Fn(&crate::core::MediaInfo) + Send + Sync + 'static) -> Self {
self.events.load.push(Arc::new(handler));
self
}
pub fn on_error(mut self, handler: impl Fn(&crate::core::MediaError) + Send + Sync + 'static) -> Self {
self.events.error.push(Arc::new(handler));
self
}
pub fn on_ended(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.events.ended.push(Arc::new(handler));
self
}
pub fn on_started(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.events.started.push(Arc::new(handler));
self
}
pub fn on_waiting_change(mut self, handler: impl Fn(bool) + Send + Sync + 'static) -> Self {
self.events.waiting.push(Arc::new(handler));
self
}
pub fn volume(mut self, signal: Signal<f32>) -> Self {
let value = f64::from(signal.get());
self.volume.bind(value, move |next| signal.set(next as f32));
self
}
pub fn volume_controlled(mut self, volume: impl Into<f64>, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.volume.hold(volume.into(), handler);
self
}
pub fn on_volume_change(mut self, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.volume.add(handler);
self
}
pub fn on_volume_change_end(mut self, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.on_volume_change_end.push(Arc::new(handler));
self
}
held!(
muted,
muted_controlled,
on_muted_change,
bool,
bool,
"whether the sound is off."
);
pub fn rate(mut self, signal: Signal<f32>) -> Self {
let value = f64::from(signal.get());
self.rate.bind(value, move |next| signal.set(next as f32));
self
}
pub fn rate_controlled(mut self, rate: impl Into<f64>, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.rate.hold(rate.into(), handler);
self
}
pub fn on_rate_change(mut self, handler: impl Fn(f64) + Send + Sync + 'static) -> Self {
self.rate.add(handler);
self
}
pub fn rates(mut self, rates: &[f32]) -> Self {
self.rates = rates.to_vec();
self
}
held!(
captions,
captions_controlled,
on_captions_change,
bool,
bool,
"whether the captions show."
);
pub fn caption_text(mut self, text: &str) -> Self {
self.caption_text = (!text.is_empty()).then(|| Arc::from(text));
self
}
pub fn caption_cues(mut self, track: &MediaCaptions) -> Self {
self.caption_cues = Some(track.clone());
self
}
pub fn captions_track(mut self, name: &str) -> Self {
self.captions_track = Some(Arc::from(name));
self
}
pub fn captions_button(mut self, shown: bool) -> Self {
self.captions_button = shown;
self
}
pub fn settings_button(mut self, shown: bool) -> Self {
self.settings_button = shown;
self
}
pub fn looped(mut self, looped: bool) -> Self {
self.looped = looped;
self
}
fn has_captions(&self) -> bool {
self.captions_button
&& (self.caption_cues.is_some()
|| self.captions_track.is_some()
|| self.caption_text.is_some()
|| self.captions.value
|| !self.captions.handlers.is_empty())
}
pub fn qualities(mut self, qualities: &[&str]) -> Self {
self.qualities = qualities.iter().map(|quality| Arc::from(*quality)).collect();
self
}
pub fn quality(mut self, signal: Signal<Option<usize>>) -> Self {
let value = signal.get();
self.quality.bind(value, move |next| signal.set(next));
self
}
pub fn quality_controlled(
mut self,
quality: Option<usize>,
handler: impl Fn(Option<usize>) + Send + Sync + 'static,
) -> Self {
self.quality.hold(quality, handler);
self
}
pub fn on_quality_change(mut self, handler: impl Fn(Option<usize>) + Send + Sync + 'static) -> Self {
self.quality.add(handler);
self
}
held!(
fullscreen,
fullscreen_controlled,
on_fullscreen_change,
bool,
bool,
"whether it fills the screen; its button then exits."
);
pub fn fullscreen_fills(mut self, fills: VideoFullscreen) -> Self {
self.fullscreen_fills = fills;
self
}
held!(
picture_in_picture,
picture_in_picture_controlled,
on_picture_in_picture_change,
bool,
bool,
"whether it plays in a small window of its own over the others."
);
pub fn picture_in_picture_window(mut self, opens: bool) -> Self {
self.picture_in_picture_window = opens;
self
}
#[cfg(feature = "media")]
pub fn source(mut self, source: &crate::resources::Source) -> Self {
self.source = Some(source.clone());
self
}
pub fn touch(mut self, touch: bool) -> Self {
self.touch = Some(touch);
self
}
fn is_touch(&self) -> bool {
self.touch.unwrap_or_else(super::touch_form)
}
pub fn title(mut self, title: &str) -> Self {
self.title = (!title.is_empty()).then(|| Arc::from(title));
self
}
pub fn description(mut self, description: &str) -> Self {
self.description = (!description.is_empty()).then(|| Arc::from(description));
self
}
pub fn on_back(mut self, handler: impl Fn() + Send + Sync + 'static) -> Self {
self.on_back.push(Arc::new(handler));
self
}
pub fn size(mut self, size: impl Into<Name>) -> Self {
self.size = Some(size.into());
self
}
pub fn width(mut self, width: impl Into<Length>) -> Self {
self.width = Some(width.into());
self
}
pub fn max_width(mut self, width: impl Into<Length>) -> Self {
self.max_width = Some(width.into());
self
}
pub fn aspect(mut self, aspect: f32) -> Self {
if aspect.is_finite() && aspect > 0.0 {
self.aspect = aspect;
}
self
}
pub fn height(mut self, height: impl Into<Length>) -> Self {
self.height = Some(height.into());
self
}
pub fn force_menu(mut self, menu: Option<VideoPlayerMenu>) -> Self {
self.force_menu = menu;
self
}
pub fn force_controls_shown(mut self, shown: Option<bool>) -> Self {
self.force_controls_shown = shown;
self
}
words! {
label => label, "What the player is called, to what reads the tree: \"Video player\" unless told.";
play_label => play, "The name of the play button while a press would play.";
pause_label => pause, "The name of the play button while a press would pause.";
replay_label => replay, "The name of the play button once it ended.";
mute_label => mute, "The name of the mute button while a press would mute.";
unmute_label => unmute, "The name of the mute button while a press would bring the sound back.";
volume_label => volume, "The name of the volume's slider.";
seek_label => seek, "The name of the seek bar.";
captions_label => captions, "The name of the captions' button, and their row in the menus.";
speed_label => speed, "The name of the speed's button, and its row in the menus.";
speed_heading_text => speed_heading, "The heading over the speeds: \"Playback speed\".";
settings_label => settings, "The name of the settings' button.";
quality_label => quality, "The name of the quality's row in the menus.";
picture_in_picture_label => picture_in_picture, "The name of the button of picture in picture.";
in_picture_text => in_picture, "What stands where the player was while it plays in its small window.";
back_label => back, "The button that brings it back from its small window: \"Back to the window\".";
unplayable_text => unplayable, "The error's title where its source cannot be played: the reason is under it.";
fullscreen_label => fullscreen, "The name of the fullscreen button while a press would fill the screen.";
exit_fullscreen_label => exit_fullscreen, "The name of the fullscreen button while it fills the screen.";
more_label => more, "The name of the compact player's menu button.";
retry_label => retry, "The words of the error's button: \"Try again\".";
rewind_label => rewind, "The touch form: the name of the button of ten seconds back.";
forward_label => forward, "The touch form: the name of the button of ten seconds on.";
seconds_text => seconds, "The touch form: the word after the count in the mark of a double tap, \"seconds\".";
minimize_label => minimize, "The touch form: the name of the first button of the top row, upright.";
leave_label => leave, "The touch form: the name of the first button of the top row, on its side.";
auto_text => auto, "The quality the player picks: \"Auto\".";
on_text => on, "The captions on, where their track has no name: \"On\".";
off_text => off, "The captions off: \"Off\".";
live_text => live, "The badge of what is live: \"LIVE\".";
}
pub fn locale(mut self, locale: &crate::core::Locale) -> Self {
self.words = Words::of(&locale.media);
self.locale = Some(locale.media.clone());
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
}
fn shows_poster(&self) -> bool {
let standing = match (self.poster_until_frame, self.framed) {
(true, Some(framed)) => !framed,
_ => self.opening || (!self.playing.value && self.position.value <= 0.0 && !self.waiting),
};
self.poster.is_some() && !self.ended && self.error.is_none() && standing
}
pub fn build(self, theme: &Theme) -> Element {
let held = Live::still();
view(self, theme, &held, None).render_themed()
}
pub fn mount(self, ctx: &mut Ctx) -> Element {
let key = self.key.clone();
let props = VideoPlayerProps(self);
match key {
Some(key) => ctx.mount_keyed::<VideoPlayerHost>(&key, props),
None => ctx.mount::<VideoPlayerHost>(props),
}
}
}
#[derive(Clone)]
struct Live {
root: ElementRef,
row: ElementRef,
buttons: ElementRef,
menus: [Signal<bool>; 3],
page: Signal<Option<usize>>,
pressed: Arc<Mutex<Option<Instant>>>,
tapped: Arc<Mutex<Option<(Instant, i8)>>>,
mark: Signal<Option<(bool, u32)>>,
unmark: Option<Timeout>,
shown: Signal<bool>,
hide: Option<Timeout>,
show: Option<Timeout>,
remaining: Signal<bool>,
volume: Option<super::media_volume::Kept>,
bucket: Signal<u8>,
follows: Arc<AtomicBool>,
aspect: Arc<AtomicU32>,
filling: Arc<AtomicBool>,
screen: Arc<AtomicBool>,
rested: Arc<Mutex<(f32, f32)>>,
dropped: Signal<f32>,
taken: Arc<AtomicBool>,
window: Arc<Mutex<Option<crate::app::window::WindowHandle>>>,
picture: Option<Picture>,
told: Option<Timeout>,
opener: Option<crate::app::WindowOpener>,
#[cfg(feature = "media")]
played: Option<Played>,
mounted: bool,
}
#[cfg(feature = "media")]
#[derive(Clone)]
struct Played {
media: Arc<Mutex<Option<(u64, crate::media::Media)>>>,
beat: Signal<u64>,
plays: Arc<AtomicBool>,
said: Arc<Mutex<(Option<bool>, Option<f64>, Option<f64>, Option<bool>)>>,
listener: super::media_events::Listener,
_clock: crate::app::ctx::Interval,
}
#[derive(Clone)]
struct Picture {
player: Arc<Mutex<Option<VideoPlayer>>>,
changed: Signal<u64>,
open: Arc<AtomicBool>,
}
impl Picture {
fn put(&self, player: Option<VideoPlayer>) {
*self.player.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = player;
}
fn held(&self) -> Option<VideoPlayer> {
self
.player
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.clone()
}
}
fn shaped(width: f32, aspect: f32) -> f32 {
(width / aspect).round()
}
fn bucket(width: f32) -> u8 {
match VideoPlayerSize::for_width(width) {
VideoPlayerSize::Sm => 1,
VideoPlayerSize::Md => 2,
VideoPlayerSize::Lg if width < VIDEO_PLAYER_VOLUME_FOLDS_BELOW => 3,
VideoPlayerSize::Lg => 4,
}
}
impl Live {
fn still() -> Self {
Self {
root: ElementRef::new(),
row: ElementRef::new(),
buttons: ElementRef::new(),
menus: [Signal::new(false), Signal::new(false), Signal::new(false)],
page: Signal::new(None),
pressed: Arc::default(),
tapped: Arc::default(),
mark: Signal::new(None),
unmark: None,
shown: Signal::new(true),
hide: None,
show: None,
remaining: Signal::new(false),
volume: None,
bucket: Signal::new(0),
follows: Arc::new(AtomicBool::new(false)),
aspect: Arc::new(AtomicU32::new(VIDEO_PLAYER_ASPECT.to_bits())),
filling: Arc::default(),
screen: Arc::default(),
rested: Arc::default(),
dropped: Signal::new(0.0),
taken: Arc::default(),
window: Arc::default(),
picture: None,
told: None,
opener: None,
#[cfg(feature = "media")]
played: None,
mounted: false,
}
}
fn poke(&self) -> impl Fn() + Send + Sync + Clone + 'static {
let (shown, hide) = (self.shown.clone(), self.hide.clone());
move || {
if !shown.get_untracked() {
shown.set(true);
}
if let Some(hide) = &hide {
hide.restart();
}
}
}
fn menu(&self, menu: VideoPlayerMenu) -> &Signal<bool> {
&self.menus[menu as usize]
}
}
impl crate::app::component::IntoComponent for VideoPlayer {
type Component = VideoPlayerHost;
fn into_props(self) -> VideoPlayerProps {
VideoPlayerProps(self)
}
fn component_key(&self) -> Option<Arc<str>> {
self.key.clone()
}
}
#[doc(hidden)]
#[derive(Clone)]
pub struct VideoPlayerProps(VideoPlayer);
impl PartialEq for VideoPlayerProps {
fn eq(&self, _: &Self) -> bool {
false
}
}
impl crate::app::component::DevtoolsInspectable for VideoPlayerProps {}
#[doc(hidden)]
pub struct VideoPlayerHost {
live: Live,
}
impl Component for VideoPlayerHost {
type Props = VideoPlayerProps;
fn create(ctx: &mut Ctx) -> Self {
let shown = ctx.signal(true);
let hide = ctx.create_timeout(VIDEO_PLAYER_HIDE_AFTER, {
let shown = shown.clone();
move || shown.set(false)
});
let show = ctx.create_timeout(Duration::ZERO, {
let shown = shown.clone();
move || shown.set(true)
});
let picture = Picture {
player: Arc::default(),
changed: Signal::new(0),
open: Arc::default(),
};
let told = ctx.create_timeout(Duration::ZERO, {
let changed = picture.changed.clone();
move || changed.update(|count| *count += 1)
});
let mark = ctx.signal(None);
let unmark = ctx.create_timeout(VIDEO_PLAYER_MARK_STAYS, {
let mark = mark.clone();
move || mark.set(None)
});
#[cfg(feature = "media")]
let played = {
let (beat, plays) = (ctx.signal(0_u64), Arc::new(AtomicBool::new(false)));
let clock = ctx.create_interval(Duration::from_millis(250), {
let (beat, plays) = (beat.clone(), plays.clone());
move || {
if plays.load(Ordering::Relaxed) {
beat.update(|count| *count += 1);
}
}
});
clock.start();
Played {
media: Arc::default(),
beat,
plays,
said: Arc::default(),
listener: super::media_events::Listener::default(),
_clock: clock,
}
};
let live = Live {
root: ElementRef::new(),
row: ElementRef::new(),
buttons: ElementRef::new(),
menus: [ctx.signal(false), ctx.signal(false), ctx.signal(false)],
page: ctx.signal(None),
pressed: Arc::default(),
tapped: Arc::default(),
mark,
unmark: Some(unmark),
shown,
hide: Some(hide),
show: Some(show),
remaining: ctx.signal(false),
volume: Some(super::media_volume::Kept::new(ctx)),
bucket: ctx.signal(0),
follows: Arc::new(AtomicBool::new(false)),
aspect: Arc::new(AtomicU32::new(VIDEO_PLAYER_ASPECT.to_bits())),
filling: Arc::default(),
screen: Arc::default(),
rested: Arc::default(),
dropped: ctx.signal(0.0),
taken: Arc::default(),
window: Arc::default(),
picture: Some(picture),
told: Some(told),
opener: Some(ctx.window_opener()),
#[cfg(feature = "media")]
played: Some(played),
mounted: true,
};
let (bucket_of, last) = (live.bucket.clone(), Arc::new(AtomicU8::new(0)));
let (root, follows, aspect) = (live.root.mutable(), live.follows.clone(), live.aspect.clone());
let (filling, rested) = (live.filling.clone(), live.rested.clone());
live.root.observe_rect_before_paint(move |rect| {
let now = bucket(rect.width);
if last.swap(now, Ordering::Relaxed) != now {
bucket_of.set(now);
}
if filling.load(Ordering::Relaxed) {
return;
}
let mut height = rect.height;
if follows.load(Ordering::Relaxed) {
let aspect = f32::from_bits(aspect.load(Ordering::Relaxed));
height = shaped(rect.width, aspect);
root.set_size(None, Some(Dimension::Px(height)));
}
*rested.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = (rect.width, height);
});
Self { live }
}
fn on_unmounted(&self) {
if self.live.screen.swap(false, Ordering::Relaxed) {
let taken = self
.live
.window
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner())
.take();
if let Some(window) = taken {
window.set_full_screen(false);
}
}
if let Some(picture) = &self.live.picture
&& picture.open.swap(false, Ordering::Relaxed)
{
picture.put(None);
picture.changed.update(|count| *count += 1);
}
}
fn render(&self, ctx: &mut Ctx) -> impl Into<Element> {
let player = ctx.props::<VideoPlayerProps>().0.clone();
let live = &self.live;
#[cfg(feature = "media")]
let player = playing(player, live, ctx);
let fills = player.fullscreen.value && player.fullscreen_fills != VideoFullscreen::App;
live.filling.store(fills, Ordering::Relaxed);
let screen = fills && player.fullscreen_fills == VideoFullscreen::Screen;
if live.mounted && live.screen.swap(screen, Ordering::Relaxed) != screen {
let window = ctx.window();
window.set_full_screen(screen);
*live.window.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = screen.then_some(window);
}
let follows = !fills && player.height.is_none() && (player.width.is_some() || player.max_width.is_some());
live.follows.store(follows, Ordering::Relaxed);
live.aspect.store(player.aspect.to_bits(), Ordering::Relaxed);
let root = live.root.mutable();
if !follows {
root.set_size(None, None);
} else if live.root.is_attached() {
root.set_size(None, Some(Dimension::Px(shaped(live.root.width(), player.aspect))));
}
let plays = player.playing.value && !player.waiting && !player.ended && player.error.is_none();
let shown = live.shown.get();
if plays && shown {
if let Some(hide) = &live.hide
&& !hide.is_active()
{
hide.start();
}
} else if !plays {
if let Some(hide) = &live.hide {
hide.cancel();
}
if !shown
&& !player.is_touch()
&& let Some(show) = &live.show
{
show.start();
}
}
let theme = current_theme();
let away = !fills && player.picture_in_picture.value && player.picture_in_picture_window;
if let (Some(picture), Some(told)) = (&live.picture, &live.told) {
if away {
picture.put(Some(player.clone()));
if !picture.open.swap(true, Ordering::Relaxed)
&& let Some(opener) = &live.opener
{
let (wide, props) = (VIDEO_PLAYER_PICTURE_WIDTH, PictureProps(picture.clone()));
let high = shaped(wide as f32, player.aspect).max(1.0) as u32;
opener.open_with(
crate::app::WindowOptions::new(player.words.picture_in_picture.to_string(), wide, high)
.undecorated()
.always_on_top()
.window_name("picture-in-picture"),
move |app, tree| tree.mount_root::<PictureWindow>(app, props),
);
}
told.restart();
} else if picture.open.swap(false, Ordering::Relaxed) {
picture.put(None);
told.restart();
}
}
if away {
return view(in_its_window(player, &theme), &theme, live, Some(ctx)).render_themed();
}
if !fills {
return view(player, &theme, live, Some(ctx)).render_themed();
}
let rested = *live.rested.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
let (width, height, most) = (player.width, player.height, player.max_width);
let leave = {
let (tell, poke) = (player.fullscreen.teller(), live.poke());
move || {
tell(false);
poke();
}
};
let (dropped, taken) = (live.dropped.clone(), live.taken.clone());
let drop = live.dropped.get();
let safe = ctx.safe_area();
let mut inside = player;
inside.width = Some(Length::Fill);
inside.height = Some(Length::Fill);
inside.max_width = None;
let filled = view(inside, &theme, live, Some(ctx));
let mut place = Stack::new().part(&filled.part(VideoPlayerPart::Root));
if rested.0 > 0.0 {
place = place.width(rested.0).height(rested.1);
} else {
if let Some(width) = width.and_then(|width| width.resolve(&theme)) {
place = place.width(width);
}
if let Some(height) = height.and_then(|height| height.resolve(&theme)) {
place = place.height(height);
}
}
if let Some(most) = most.and_then(|most| most.resolve(&theme)) {
place = place.max_width(most);
}
let full = Dimension::Pct(100.0);
let layer = Modal::new(
Stack::new()
.size(full, full)
.background(Color::new(0, 0, 0, 255))
.padding_top(safe.top)
.padding_bottom(safe.bottom)
.padding_left(safe.left)
.padding_right(safe.right)
.on_pan(move |event: PanEvent| match event.phase {
GesturePhase::Start => {
let down = event.translation_y > 0.0 && event.translation_y.abs() > event.translation_x.abs();
if down && event.fingers == 1 {
event.prevent_default();
taken.store(true, Ordering::Relaxed);
dropped.set(event.translation_y);
}
}
GesturePhase::Change if taken.load(Ordering::Relaxed) => dropped.set(event.translation_y.max(0.0)),
GesturePhase::End if taken.swap(false, Ordering::Relaxed) => {
dropped.set(0.0);
if event.translation_y > VIDEO_PLAYER_DROP_LEAVES || event.velocity_y > VIDEO_PLAYER_THROW_LEAVES {
leave();
}
}
_ => {}
})
.child(
Stack::new()
.size(full, full)
.offset(0.0, drop)
.child(filled.render_themed()),
),
)
.target(Root)
.takes_focus(true);
place.child(layer).into()
}
}
#[cfg(feature = "media")]
fn playing(mut player: VideoPlayer, live: &Live, ctx: &mut Ctx) -> VideoPlayer {
use crate::media::Media;
let Some(played) = &live.played else {
return player;
};
let mut held = played.media.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
let Some(source) = player.source.take() else {
*held = None;
played.plays.store(false, Ordering::Relaxed);
return player;
};
#[cfg(any(feature = "devtools", feature = "mcp"))]
{
player.said_source = Some(Arc::from(format!("{source:?}")));
}
played.beat.get();
let key = source.cache_key();
if held.as_ref().is_none_or(|(of, _)| *of != key) {
let loader = ctx
.app_handle()
.map_or_else(crate::resources::Loader::new, |app| app.loader().clone());
let media = Media::open(&loader, &source);
let beat = played.beat.clone();
media.on_change(move || beat.update(|count| *count += 1));
played.listener.listen(&media);
*held = Some((key, media));
*played.said.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = (None, None, None, None);
}
let media = held
.as_ref()
.map(|(_, media)| media.clone())
.expect("the media just held");
drop(held);
{
let mut said = played.said.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
if said.0 != Some(player.playing.value) {
let answers = played.listener.answers(player.playing.value);
if player.playing.value && !answers {
media.play();
} else if said.0.is_some() && !answers {
media.pause();
}
if said.0.is_some() {
played.listener.known(player.playing.value);
} else {
played.listener.first(player.playing.value);
}
said.0 = Some(player.playing.value);
}
if said.1 != Some(player.rate.value) {
media.set_rate(player.rate.value);
said.1 = Some(player.rate.value);
}
if said.2 != Some(player.volume.value) {
media.set_volume(player.volume.value as f32);
said.2 = Some(player.volume.value);
}
if said.3 != Some(player.muted.value) {
media.set_muted(player.muted.value);
said.3 = Some(player.muted.value);
}
if media.looped() != player.looped {
media.set_looped(player.looped);
}
}
let again = {
let beat = played.beat.clone();
move || beat.update(|count| *count += 1)
};
played.listener.update(&player.events, &player.playing.handlers);
player.playing.add({
let (media, again, listener) = (media.clone(), again.clone(), played.listener.clone());
move |to| {
listener.known(to);
if to {
media.play();
} else {
media.pause();
}
again();
}
});
player.position.add({
let (media, again) = (media.clone(), again.clone());
move |to| {
media.seek(to);
again();
}
});
player.rate.add({
let (media, again) = (media.clone(), again.clone());
move |to| {
media.set_rate(to);
again();
}
});
player.volume.add({
let (media, again) = (media.clone(), again.clone());
move |to| {
media.set_volume(to as f32);
again();
}
});
player.muted.add({
let (media, again) = (media.clone(), again.clone());
move |to| {
media.set_muted(to);
again();
}
});
player.on_retry.push({
let (held, again) = (played.media.clone(), again);
Arc::new(move || {
*held.lock().unwrap_or_else(|poisoned| poisoned.into_inner()) = None;
again();
})
});
let state = media.state();
played.plays.store(state.playing, Ordering::Relaxed);
player.playing.value = state.playing;
player.position.value = state.position;
player.rate.value = state.rate;
player.volume.value = f64::from(state.volume);
player.muted.value = state.muted;
if state.duration.is_some() {
player.duration = state.duration;
}
player.buffered = player.buffered.or(state.buffered);
player.waiting = player.waiting || state.waiting;
player.ended = player.ended || state.ended;
if let (None, Some(why)) = (&player.error, &state.error) {
player.error = Some(player.words.unplayable.clone());
player.error_description = Some(match &player.locale {
Some(words) => words.error(why),
None => super::current_locale().media.error(why),
});
}
let pictured = media.has_frame();
player.framed = Some(pictured);
player.opening = state.error.is_none() && (!media.is_open() || (state.size.is_some() && !pictured));
if let Some(image) = media.frame().filter(|_| pictured) {
player.media = Some(
crate::components::Video::new(image)
.contain()
.size(Dimension::Pct(100.0), Dimension::Pct(100.0))
.into(),
);
}
player
}
fn said_to_tooling(player: &VideoPlayer) -> Vec<(&'static str, Arc<str>)> {
if !cfg!(any(feature = "devtools", feature = "mcp")) {
return Vec::new();
}
let state = if player.error.is_some() {
"failed"
} else if player.opening {
"opening"
} else if player.ended {
"ended"
} else if player.waiting {
"waiting"
} else if player.playing.value {
"playing"
} else {
"paused"
};
super::media_time::said_to_tooling(
state,
player.position.value,
player.duration,
player.said_source.as_ref(),
)
}
fn parts(player: &VideoPlayer, theme: &Theme, size: VideoPlayerSize) -> ResolvedRecipe {
let case = Case {
variant: None,
size: Some(size.into()),
density: None,
breakpoint: super::current_breakpoint(),
states: player.states.clone(),
};
theme
.resolve::<VideoPlayer>(&case, Some(&player.rules))
.owned_by(player.id.as_ref())
}
fn in_its_window(mut player: VideoPlayer, theme: &Theme) -> VideoPlayer {
let recipe = parts(&player, theme, VideoPlayerSize::Lg);
let (title, button) = (recipe.part(VideoPlayerPart::Title), recipe.part(VideoPlayerPart::Retry));
let back = player.picture_in_picture.teller();
let mut leave = pressable(&button, false)
.describe("a11y_role", "button")
.describe("a11y_name", player.words.back.clone())
.child(button.text(&player.words.back).nowrap())
.on_click(move |_| back(false));
if let Some(id) = &player.id {
leave = leave.id(format!("{id}-back"));
}
let said = Column::new()
.size(Dimension::Pct(100.0), Dimension::Pct(100.0))
.align_items(Alignment::Center)
.justify(Justify::Center)
.spacing(12.0)
.child(glyph(
&recipe.part(VideoPlayerPart::ErrorIcon),
Name::new(icons::PICTURE_IN_PICTURE),
false,
))
.child(
title
.text(&player.words.in_picture)
.text_align(TextAlign::Center)
.part(&title),
)
.child(leave);
player.media = None;
player.poster = None;
player.controls = false;
player.children = vec![said.into()];
player
}
#[derive(Clone)]
struct PictureProps(Picture);
impl PartialEq for PictureProps {
fn eq(&self, other: &Self) -> bool {
Arc::ptr_eq(&self.0.player, &other.0.player)
}
}
impl crate::app::component::DevtoolsInspectable for PictureProps {}
struct PictureWindow;
impl Component for PictureWindow {
type Props = PictureProps;
fn create(_: &mut Ctx) -> Self {
Self
}
fn render(&self, ctx: &mut Ctx) -> impl Into<Element> {
let picture = ctx.props::<PictureProps>().0.clone();
picture.changed.get();
let window = ctx.window();
window.on_close_requested({
let picture = picture.clone();
move |request| {
if let Some(player) = picture.held() {
(player.picture_in_picture.teller())(false);
}
request.proceed();
}
});
let black = Color::new(0, 0, 0, 255);
let Some(mut player) = picture.held() else {
window.close();
let empty: Element = Stack::new()
.size(Dimension::Pct(100.0), Dimension::Pct(100.0))
.background(black)
.into();
return empty;
};
let theme = current_theme();
let recipe = parts(&player, &theme, VideoPlayerSize::Md);
let leave = player.picture_in_picture.teller();
let back = pressable(&recipe.part(VideoPlayerPart::Control), false)
.describe("a11y_role", "button")
.describe("a11y_name", player.words.back.clone())
.child(glyph(
&recipe.part(VideoPlayerPart::ControlIcon),
Name::new(icons::PICTURE_IN_PICTURE),
false,
))
.on_click(move |_| leave(false));
let grip = Row::new()
.flex(1.0)
.height(Dimension::Pct(100.0))
.on_mouse_down(move |_: MouseEvent| window.start_drag());
let top = Row::new()
.width(Dimension::Pct(100.0))
.height(36.0)
.padding(4.0)
.align_items(Alignment::Center)
.child(grip)
.child(back);
player.children.push(
Column::new()
.size(Dimension::Pct(100.0), Dimension::Pct(100.0))
.hit_test(HitTestBehavior::ContentOnly)
.child(top)
.into(),
);
player.width = Some(Length::Fill);
player.height = Some(Length::Fill);
player.max_width = None;
player.size = Some(VideoPlayerSize::Sm.into());
player = player.style(VideoPlayerPart::Root, |s| s.radius(0.0));
player.picture_in_picture_window = false;
player.fullscreen_fills = VideoFullscreen::App;
#[cfg(feature = "media")]
{
player.source = None;
}
player.id = None;
player.key = None;
Stack::new()
.size(Dimension::Pct(100.0), Dimension::Pct(100.0))
.background(black)
.child(player.mount(ctx))
.into()
}
}
fn view(mut player: VideoPlayer, theme: &Theme, live: &Live, ctx: Option<&mut Ctx>) -> VideoPlayerView {
player.touch = Some(player.is_touch());
let measured = match live.bucket.get() {
0 => match player.width.and_then(|width| width.resolve(theme)) {
Some(Dimension::Px(width)) => bucket(width),
_ => 0,
},
measured => measured,
};
let form = match player.size {
Some(size) => VideoPlayerSize::of(size),
None => match measured {
1 => VideoPlayerSize::Sm,
2 => VideoPlayerSize::Md,
_ => VideoPlayerSize::Lg,
},
};
let narrow = matches!(measured, 1..=3);
let poster = player.shows_poster();
let menu_open = player.force_menu.is_some() || live.menus.iter().any(|open| open.get());
let resting = player.playing.value && !player.waiting && !player.ended && player.error.is_none();
let shown = player.force_controls_shown.unwrap_or_else(|| {
(!resting && !player.is_touch())
|| live.shown.get()
|| menu_open
|| (live.mounted && live.root.focus_visible_within())
});
let has_bar = player.controls && player.error.is_none() && !poster;
let landscape = player.is_touch() && player.fullscreen.value;
let case = Case {
variant: None,
size: Some(form.into()),
density: None,
breakpoint: super::current_breakpoint(),
states: player.states.clone(),
}
.state(VideoPlayerState::Playing, player.playing.value)
.state(VideoPlayerState::Waiting, player.waiting)
.state(VideoPlayerState::Ended, player.ended)
.state(VideoPlayerState::Error, player.error.is_some())
.state(VideoPlayerState::Live, player.live)
.state(VideoPlayerState::Muted, player.muted.value)
.state(VideoPlayerState::Captions, player.captions.value)
.state(VideoPlayerState::Fullscreen, player.fullscreen.value)
.state(VideoPlayerState::Poster, poster)
.state(VideoPlayerState::Bare, !player.controls)
.state(VideoPlayerState::Hidden, has_bar && !shown && !player.is_touch())
.state(VideoPlayerState::Touch, player.is_touch())
.state(VideoPlayerState::Landscape, landscape)
.state(VideoPlayerState::Narrow, narrow);
let recipe = theme
.resolve::<VideoPlayer>(&case, Some(&player.rules))
.owned_by(player.id.as_ref());
let on_recipe = theme
.resolve::<VideoPlayer>(&case.clone().state(VideoPlayerState::On, true), Some(&player.rules))
.owned_like(&recipe);
let mut make = Make {
player: &player,
recipe: &recipe,
on_recipe: &on_recipe,
live,
ctx,
form,
shown,
};
let touch = (player.is_touch() && player.controls).then(|| make.touch(landscape));
let bar = (has_bar && !player.is_touch()).then(|| make.bar(narrow));
let center = (player.controls && (!player.is_touch() || player.error.is_some() || player.waiting))
.then(|| make.center())
.flatten();
let tap = (player.is_touch() && player.controls && player.error.is_none()).then(|| make.tap());
let retry = make.retry();
let root_keys: Arc<dyn Fn(KeyboardEvent) + Send + Sync> = Arc::new(make.keys());
let mut children = player.children.clone();
if !player.layers.is_empty() {
let playback = VideoPlayback {
playing: player.playing.value,
waiting: player.waiting,
ended: player.ended,
failed: player.error.is_some(),
opening: player.opening,
poster_shown: poster,
position: if player.ended {
player.duration.unwrap_or(player.position.value)
} else {
player.position.value
},
duration: player.duration,
buffered: player.buffered,
volume: player.volume.value,
muted: player.muted.value,
rate: player.rate.value,
seek: Arc::new(make.seeker()),
play: Arc::new(player.playing.teller()),
mute: Arc::new(player.muted.teller()),
};
children.extend(player.layers.iter().map(|layer| {
let mut build = layer.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
build(&playback)
}));
}
VideoPlayerView {
form,
narrow,
controls: player.controls,
bar_shown: shown,
poster_shown: poster,
playing: player.playing.value,
waiting: player.waiting,
ended: player.ended,
live: player.live,
duration: player.duration,
error: player.error.clone(),
error_description: player.error_description.clone(),
caption: (player.controls && player.captions.value && player.error.is_none())
.then(|| {
player.caption_text.clone().or_else(|| {
player
.caption_cues
.as_ref()
.and_then(|track| track.at(player.position.value))
})
})
.flatten(),
label: player.words.label.clone(),
width: player.width,
height: player.height,
max_width: player.max_width,
aspect: player.aspect,
media: player.media.clone().filter(|_| !poster),
poster: player.poster.clone().filter(|_| poster),
children,
bar,
center,
retry,
keys: root_keys,
touch,
tap,
toggle: make.toggle(),
pressed: live.pressed.clone(),
fullscreen: make.fullscreen_toggle(),
poke: (live.mounted && !player.is_touch()).then(|| Arc::new(live.poke()) as Action),
root: live.root.clone(),
tooling: said_to_tooling(&player),
mounted: live.mounted || player.force_menu.is_some(),
filling: live.filling.load(Ordering::Relaxed),
recipe,
id: player.id.clone(),
}
}
struct Make<'a, 'c> {
player: &'a VideoPlayer,
recipe: &'a ResolvedRecipe,
on_recipe: &'a ResolvedRecipe,
live: &'a Live,
ctx: Option<&'c mut Ctx>,
form: VideoPlayerSize,
shown: bool,
}
pub struct VideoPlayerTouch {
pub landscape: bool,
pub lead: Option<Element>,
pub heading: Option<Element>,
pub tools: Vec<Element>,
pub transport: Option<Element>,
pub time: Element,
pub foot: Vec<Element>,
pub seek: Element,
pub menus: Vec<Element>,
pub mark: Option<Element>,
pub top: ElementRef,
pub row: ElementRef,
}
pub struct VideoPlayerBar {
pub seek: Element,
pub play: Element,
pub volume: Option<Element>,
pub time: Element,
pub volume_out: bool,
pub end: Vec<Element>,
pub menus: Vec<Element>,
pub row: ElementRef,
pub buttons: ElementRef,
pub height: f32,
}
impl Make<'_, '_> {
fn part(&self, part: VideoPlayerPart) -> ResolvedPart {
self.recipe.part(part).forced(self.player.forced)
}
fn id(&self, suffix: &str) -> Option<String> {
self.player.id.as_ref().map(|id| format!("{id}-{suffix}"))
}
fn tip(&mut self, element: Element, text: &str, keys: &str) -> Element {
let faded = (!self.shown).then_some(false);
match self.ctx.as_deref_mut() {
Some(ctx) => Tooltip::new(text)
.shortcut(keys)
.placement(Placement::Top)
.arrow(true)
.offset(4.0)
.force_open(faded)
.mount(ctx, element),
None => element,
}
}
fn pressed<T: Copy + Send + Sync + 'static>(&self, tell: impl Fn(T) + Send + Sync + 'static, value: T) -> Action {
let poke = self.live.mounted.then(|| self.live.poke());
Arc::new(move || {
tell(value);
if let Some(poke) = &poke {
poke();
}
})
}
fn control(&mut self, suffix: &str, icon: &'static str, label: &str, keys: &str, on: bool, press: Action) -> Element {
let recipe = if on { self.on_recipe } else { self.recipe };
let part = recipe.part(VideoPlayerPart::Control).forced(self.player.forced);
let mut button = pressable(&part, false)
.describe("a11y_role", "button")
.describe("a11y_name", Arc::<str>::from(label))
.child(glyph(
&recipe.part(VideoPlayerPart::ControlIcon),
Name::new(icon),
false,
))
.on_click(move |_| press());
if let Some(id) = self.id(suffix) {
button = button.id(id);
}
self.tip(button.into(), label, keys)
}
fn toggle_control(
&mut self,
suffix: &str,
icon: &'static str,
label: &str,
keys: &str,
on: bool,
press: Action,
) -> Element {
let mut element = self.control(suffix, icon, label, keys, on, press);
crate::node::NodeUpdate::describe(
&mut *element.node,
Arc::from("a11y_pressed"),
Arc::from(if on { "true" } else { "false" }),
);
element
}
fn toggle(&self) -> Action {
let next = self.player.ended || !self.player.playing.value;
self.pressed(self.player.playing.teller(), next)
}
fn fullscreen_toggle(&self) -> Action {
self.pressed(self.player.fullscreen.teller(), !self.player.fullscreen.value)
}
fn play(&mut self) -> Element {
let player = self.player;
let (icon, label) = if player.ended {
(icons::ROTATE_LEFT, player.words.replay.clone())
} else if player.playing.value {
(icons::PAUSE, player.words.pause.clone())
} else {
(icons::PLAY, player.words.play.clone())
};
let press = self.toggle();
self.control("play", icon, &label, "K", false, press)
}
fn seeker(&self) -> impl Fn(f64) + Send + Sync + Clone + 'static {
let (tell, ends) = (
self.player.position.teller(),
self.player.on_position_change_end.clone(),
);
let end = self.player.duration.unwrap_or(f64::INFINITY);
move |to: f64| {
let to = to.clamp(0.0, end);
tell(to);
for handler in &ends {
handler(to);
}
}
}
fn seek(&mut self) -> Element {
let player = self.player;
let (position, duration) = match (player.live, player.duration) {
(true, None) => (1.0, 1.0),
(_, duration) => {
let duration = duration.unwrap_or(0.0);
let position = if player.ended { duration } else { player.position.value };
(position.min(duration), duration)
}
};
let seekable = !player.live || player.duration.is_some();
let tell = player.position.teller();
let ends = player.on_position_change_end.clone();
let poke = self.live.mounted.then(|| self.live.poke());
let mut bar = SeekBar::controlled(position, duration, move |to| {
if !seekable {
return;
}
tell(to);
if let Some(poke) = &poke {
poke();
}
})
.on_change_end(move |to| {
if !seekable {
return;
}
for handler in &ends {
handler(to);
}
})
.on_media(true)
.live(!seekable)
.label(&player.words.seek)
.step(VIDEO_PLAYER_SEEK_STEP)
.chapters(&player.chapters);
if let Some(buffered) = player.buffered {
bar = bar.buffered(buffered);
}
if let Some(preview) = player.preview.clone() {
bar = bar.preview(move |at| preview(at));
}
if let Some(id) = self.id("seek") {
bar = bar.id(id);
}
if player.is_touch() {
bar = bar.size(super::SeekBarSize::Lg);
}
match self.ctx.as_deref_mut() {
Some(ctx) => bar.mount(ctx),
None => bar.build(self.recipe.theme()),
}
}
fn time(&mut self) -> Element {
let player = self.player;
let part = self.part(VideoPlayerPart::Time);
let shown: Element = if player.live {
let mut time = MediaTime::new(player.position.value, None)
.live(true)
.live_text(&player.words.live)
.on_media(true);
if let Some(id) = self.id("time") {
time = time.id(id);
}
time.build(self.recipe.theme())
} else if self.form == VideoPlayerSize::Sm && !player.is_touch() {
let elapsed = self.part(VideoPlayerPart::Elapsed);
let hours = player.duration.is_some_and(|duration| duration >= 3600.0);
Row::new()
.part(&elapsed)
.child(elapsed.text(&media_time_text(player.position.value, hours)).nowrap())
.into()
} else {
let remaining = self.live.remaining.clone();
let size = match (player.is_touch(), player.fullscreen.value, self.form) {
(true, true, _) => MediaTimeSize::Lg,
(true, false, _) => MediaTimeSize::Md,
(false, _, VideoPlayerSize::Md) => MediaTimeSize::Sm,
(false, ..) => MediaTimeSize::Md,
};
let mut time = MediaTime::new(player.position.value, player.duration)
.remaining(remaining.get())
.size(size)
.on_media(true)
.on_click(move |_| remaining.update(|remaining| *remaining = !*remaining));
if let Some(id) = self.id("time") {
time = time.id(id);
}
time.build(self.recipe.theme())
};
Row::new()
.part(&part.unnamed())
.align_items(Alignment::Center)
.child(shown)
.into()
}
fn volume(&mut self, narrow: bool) -> Element {
let player = self.player;
let (tell, poke) = (player.volume.teller(), self.live.mounted.then(|| self.live.poke()));
let ends = player.on_volume_change_end.clone();
let mut volume = MediaVolume::controlled(player.volume.value, move |to| {
tell(to);
if let Some(poke) = &poke {
poke();
}
})
.muted_controlled(player.muted.value, player.muted.teller())
.on_change_end(move |to| {
for handler in &ends {
handler(to);
}
})
.on_media(true)
.size(MediaVolumeSize::Lg)
.length(64.0)
.collapsed(narrow)
.label(&player.words.volume)
.mute_label(&player.words.mute)
.unmute_label(&player.words.unmute)
.force(player.forced);
if let Some(id) = self.id("mute") {
volume = volume.id(id);
}
if let Some(kept) = &self.live.volume {
volume = volume.kept(kept.clone());
}
let text = if player.muted.value {
player.words.unmute.clone()
} else {
player.words.mute.clone()
};
let recipe = self.recipe;
let faded = (!self.shown).then_some(false);
match self.ctx.as_deref_mut() {
Some(ctx) => volume.build_with(recipe.theme(), &mut |button| {
Tooltip::new(&text)
.shortcut("M")
.placement(Placement::Top)
.arrow(true)
.offset(4.0)
.force_open(faded)
.mount(ctx, button)
}),
None => volume.build(recipe.theme()),
}
}
fn mute(&mut self) -> Element {
let player = self.player;
let level = player.volume.value;
let icon = if player.muted.value || level <= 0.0 {
icons::VOLUME_OFF
} else if level < 0.5 {
icons::VOLUME_LOW
} else {
icons::VOLUME
};
let label = if player.muted.value {
player.words.unmute.clone()
} else {
player.words.mute.clone()
};
let press = self.pressed(player.muted.teller(), !player.muted.value);
self.toggle_control("mute", icon, &label, "M", false, press)
}
fn menu_button(&mut self, menu: VideoPlayerMenu, suffix: &str, icon: Option<&'static str>, label: &str) -> Element {
let open = self.live.menu(menu).clone();
let is_open = self.player.force_menu == Some(menu) || open.get();
let poke = self.live.mounted.then(|| self.live.poke());
let press: Action = Arc::new(move || {
open.update(|open| *open = !*open);
if let Some(poke) = &poke {
poke();
}
});
let mut element = match icon {
Some(icon) => self.control(suffix, icon, label, "", is_open, press),
None => {
let recipe = if is_open { self.on_recipe } else { self.recipe };
let part = recipe.part(VideoPlayerPart::Speed).forced(self.player.forced);
let words = format!("{}×", self.player.rate.value);
let mut button = pressable(&part, false)
.describe("a11y_role", "button")
.describe("a11y_name", Arc::<str>::from(label))
.child(part.text(&words).nowrap())
.on_click(move |_| press());
if let Some(id) = self.id(suffix) {
button = button.id(id);
}
self.tip(button.into(), label, "")
}
};
let node = &mut *element.node;
crate::node::NodeUpdate::describe(node, Arc::from("a11y_haspopup"), Arc::from("menu"));
crate::node::NodeUpdate::describe(
node,
Arc::from("a11y_expanded"),
Arc::from(if is_open { "true" } else { "false" }),
);
element
}
fn menu_shell(&self, menu: VideoPlayerMenu, panel: VideoPlayerPart, label: &str) -> Menu {
let suffix = match menu {
VideoPlayerMenu::Settings => "settings-menu",
VideoPlayerMenu::Speed => "speed-menu",
VideoPlayerMenu::More => "more-menu",
};
let (anchor, placement) = if self.player.is_touch() {
(self.live.buttons.clone(), Placement::BottomEnd)
} else {
(self.live.row.clone(), Placement::TopEnd)
};
let shell = if self.player.force_menu == Some(menu) {
Menu::controlled(true, anchor, |_| {})
} else {
Menu::new(self.live.menu(menu).clone(), anchor)
};
let above = self.above();
let shell = match self.id(suffix) {
Some(id) => shell.id(id),
None => shell,
};
shell
.label(label)
.placement(placement)
.offset(above)
.page(self.live.page.clone())
.rules(&self.recipe.rules_for(panel, MenuPart::Panel))
}
fn above(&self) -> f32 {
let theme = self.recipe.theme();
self
.recipe
.part(VideoPlayerPart::Menus)
.rest()
.gap
.map(|gap| gap.resolve(&theme.spacing(), 0.0))
.unwrap_or(4.0)
}
fn page(&self, icon: &'static str, label: &str, value: &str, choices: Vec<MenuItem>) -> MenuItem {
MenuItem::new(label)
.icon(icon)
.shortcut(value)
.rules(
&self
.recipe
.rules_for(VideoPlayerPart::MenuValue, MenuItemPart::Shortcut),
)
.page(choices)
}
fn quality_page(&self) -> Option<MenuItem> {
let player = self.player;
if player.qualities.is_empty() {
return None;
}
let chosen = player.quality.value;
let value = chosen
.and_then(|index| player.qualities.get(index).cloned())
.unwrap_or_else(|| player.words.auto.clone());
let tell = player.quality.teller();
let choices = std::iter::once((None, player.words.auto.clone()))
.chain(
player
.qualities
.iter()
.enumerate()
.map(|(index, name)| (Some(index), name.clone())),
)
.map(|(quality, name)| {
let tell = tell.clone();
let is = quality == chosen;
MenuItem::new(&name).checked(is).on_select(move || {
if !is {
tell(quality);
}
})
})
.collect();
Some(self.page(icons::SLIDERS, &player.words.quality, &value, choices))
}
fn speed_items(&self) -> Vec<MenuItem> {
let player = self.player;
let tell = player.rate.teller();
player
.rates
.iter()
.map(|offered| {
let (offered, tell) = (f64::from(*offered), tell.clone());
let is = (offered - player.rate.value).abs() < 1e-6;
MenuItem::new(&media_rate_text(offered as f32))
.checked(is)
.on_select(move || {
if !is {
tell(offered);
}
})
})
.collect()
}
fn speed_page(&self) -> Option<MenuItem> {
let player = self.player;
(!player.live).then(|| {
let value = media_rate_text(player.rate.value as f32);
self.page(icons::GAUGE, &player.words.speed, &value, self.speed_items())
})
}
fn captions_row(&self) -> Option<MenuItem> {
self.player.has_captions().then(|| self.captions_page())
}
fn has_settings(&self) -> bool {
let player = self.player;
player.settings_button && (!player.qualities.is_empty() || !player.live || player.has_captions())
}
fn captions_page(&self) -> MenuItem {
let player = self.player;
let track = player.captions_track.clone().unwrap_or_else(|| player.words.on.clone());
let on = player.captions.value;
let tell = player.captions.teller();
let choices = [(false, player.words.off.clone()), (true, track.clone())]
.into_iter()
.map(|(choice, name)| {
let tell = tell.clone();
MenuItem::new(&name).checked(choice == on).on_select(move || {
if choice != on {
tell(choice);
}
})
})
.collect();
let value = if on { track } else { player.words.off.clone() };
self.page(icons::CAPTIONS, &player.words.captions, &value, choices)
}
fn settings_menu(&self) -> Element {
let player = self.player;
let items: Vec<MenuItem> = [self.quality_page(), self.speed_page(), self.captions_row()]
.into_iter()
.flatten()
.collect();
self
.menu_shell(
VideoPlayerMenu::Settings,
VideoPlayerPart::SettingsMenu,
&player.words.settings,
)
.items(items)
.build(self.recipe.theme())
}
fn speed_menu(&self) -> Element {
let player = self.player;
let open = if player.force_menu == Some(VideoPlayerMenu::Speed) {
Signal::new(true)
} else {
self.live.menu(VideoPlayerMenu::Speed).clone()
};
let mut menu = MediaSpeedMenu::new(open, self.live.row.clone(), player.rate.value as f32)
.rates(&player.rates)
.heading_text(&player.words.speed_heading)
.label(&player.words.speed)
.placement(Placement::TopEnd)
.offset(self.above())
.on_change(player.rate.teller());
if let Some(id) = self.id("speed-menu") {
menu = menu.id(id);
}
menu.build(self.recipe.theme())
}
fn more_menu(&self) -> Element {
let player = self.player;
let pip = player.picture_in_picture.value;
let tell = player.picture_in_picture.teller();
let picture = MenuItem::new(&player.words.picture_in_picture)
.icon(icons::PICTURE_IN_PICTURE)
.checked(pip)
.on_select(move || tell(!pip));
let items: Vec<MenuItem> = [
self.captions_row(),
self.speed_page(),
self.quality_page(),
Some(picture),
]
.into_iter()
.flatten()
.collect();
self
.menu_shell(VideoPlayerMenu::More, VideoPlayerPart::MoreMenu, &player.words.more)
.items(items)
.build(self.recipe.theme())
}
fn touch_button(
&mut self,
suffix: &str,
(button, glyph_of): (VideoPlayerPart, VideoPlayerPart),
icon: &'static str,
label: &str,
on: bool,
press: Action,
) -> Element {
let recipe = if on { self.on_recipe } else { self.recipe };
let part = recipe.part(button).forced(self.player.forced);
let mut made = pressable(&part, false)
.describe("a11y_role", "button")
.describe("a11y_name", Arc::<str>::from(label))
.child(glyph(&recipe.part(glyph_of), Name::new(icon), false))
.on_click(move |_| press());
if let Some(id) = self.id(suffix) {
made = made.id(id);
}
made.into()
}
fn touch(&mut self, landscape: bool) -> VideoPlayerTouch {
use VideoPlayerPart::{Disc, DiscIcon, Skip, SkipIcon, Touch, TouchIcon};
let player = self.player;
let seek = self.seek();
let time = self.time();
let poke = self.live.mounted.then(|| self.live.poke());
let lead = (landscape || !player.on_back.is_empty()).then(|| {
let (handlers, exit) = (player.on_back.clone(), self.fullscreen_toggle());
let press: Action = Arc::new(move || {
if handlers.is_empty() {
exit();
}
for handler in &handlers {
handler();
}
});
let (icon, label) = if landscape {
(icons::CHEVRON_LEFT, player.words.leave.clone())
} else {
(icons::CHEVRON_DOWN, player.words.minimize.clone())
};
self.touch_button("back", (Touch, TouchIcon), icon, &label, false, press)
});
let heading = (landscape && player.title.is_some()).then(|| {
let (title, line) = (self.part(VideoPlayerPart::Title), self.part(VideoPlayerPart::Line));
let mut words = Column::new().part(&self.part(VideoPlayerPart::Heading));
if let Some(said) = &player.title {
words = words.child(title.text(said).nowrap().part(&title));
}
if let Some(said) = &player.description {
words = words.child(line.text(said).nowrap().part(&line));
}
words.into()
});
let mut tools = Vec::new();
if player.has_captions() {
let captions_on = player.captions.value;
let press = self.pressed(player.captions.teller(), !captions_on);
tools.push(self.touch_button(
"captions",
(Touch, TouchIcon),
icons::CAPTIONS,
&player.words.captions,
captions_on,
press,
));
}
let mut menus = Vec::new();
if self.has_settings() {
let open = self.live.menu(VideoPlayerMenu::Settings).clone();
let is_open = player.force_menu == Some(VideoPlayerMenu::Settings) || open.get();
let poke = poke.clone();
let press: Action = Arc::new(move || {
open.update(|open| *open = !*open);
if let Some(poke) = &poke {
poke();
}
});
tools.push(self.touch_button(
"settings",
(Touch, TouchIcon),
icons::SETTINGS,
&player.words.settings,
is_open,
press,
));
menus.push(self.settings_menu());
}
let transport = (player.error.is_none() && !player.waiting).then(|| {
let seekable = !player.live || player.duration.is_some();
let step = |by: f64| -> Action {
let (seek, position, poke) = (self.seeker(), player.position.value, poke.clone());
Arc::new(move || {
if seekable {
seek(position + by);
}
if let Some(poke) = &poke {
poke();
}
})
};
let (back, on) = (step(-VIDEO_PLAYER_TAP_SEEKS), step(VIDEO_PLAYER_TAP_SEEKS));
let rewind = self.touch_button(
"rewind",
(Skip, SkipIcon),
icons::REWIND_10,
&player.words.rewind,
false,
back,
);
let forward = self.touch_button(
"forward",
(Skip, SkipIcon),
icons::FORWARD_10,
&player.words.forward,
false,
on,
);
let (icon, label) = if player.ended {
(icons::ROTATE_LEFT, player.words.replay.clone())
} else if player.playing.value {
(icons::PAUSE, player.words.pause.clone())
} else {
(icons::PLAY, player.words.play.clone())
};
let press = self.toggle();
let disc = self.touch_button("play", (Disc, DiscIcon), icon, &label, false, press);
Row::new()
.part(&self.part(VideoPlayerPart::Transport))
.align_items(Alignment::Center)
.child(rewind)
.child(disc)
.child(forward)
.into()
});
let mut foot = Vec::new();
if landscape && !player.live {
let open = self.live.menu(VideoPlayerMenu::Speed).clone();
let is_open = player.force_menu == Some(VideoPlayerMenu::Speed) || open.get();
let recipe = if is_open { self.on_recipe } else { self.recipe };
let part = recipe.part(VideoPlayerPart::Pill).forced(player.forced);
let poke = poke.clone();
let mut pill = pressable(&part, false)
.describe("a11y_role", "button")
.describe("a11y_name", player.words.speed.clone())
.child(part.text(&format!("{}×", player.rate.value)).nowrap())
.on_click(move |_| {
open.update(|open| *open = !*open);
if let Some(poke) = &poke {
poke();
}
});
if let Some(id) = self.id("speed") {
pill = pill.id(id);
}
foot.push(pill.into());
menus.push(self.speed_menu());
}
let full = player.fullscreen.value;
let (icon, label) = if full {
(icons::FULLSCREEN_EXIT, player.words.exit_fullscreen.clone())
} else {
(icons::FULLSCREEN, player.words.fullscreen.clone())
};
let press = self.fullscreen_toggle();
foot.push(self.touch_button("fullscreen", (Touch, TouchIcon), icon, &label, false, press));
VideoPlayerTouch {
landscape,
lead,
heading,
tools,
transport,
time,
foot,
seek,
menus,
mark: self.mark(),
top: self.live.buttons.clone(),
row: self.live.row.clone(),
}
}
fn mark(&self) -> Option<Element> {
let (forward, seconds) = self.live.mark.get()?;
let (mark, text) = (self.part(VideoPlayerPart::Mark), self.part(VideoPlayerPart::MarkText));
let wide = match mark.rest().width.and_then(|width| width.resolve(self.recipe.theme())) {
Some(Dimension::Px(px)) => px,
_ => 288.0,
};
let said = Column::new()
.width(wide / 2.0)
.height(Dimension::Pct(100.0))
.align_items(Alignment::Center)
.justify(Justify::Center)
.spacing(mark.rest().gap.unwrap_or_default())
.child(glyph(
&self.part(VideoPlayerPart::MarkIcon),
Name::new(if forward { icons::FORWARD_10 } else { icons::REWIND_10 }),
false,
))
.child(
text
.text(&format!("{seconds} {}", self.player.words.seconds))
.nowrap()
.part(&text),
);
let blank = Row::new().width(wide / 2.0);
let halves: [Element; 2] = if forward {
[said.into(), blank.into()]
} else {
[blank.into(), said.into()]
};
let ellipse = Row::new()
.part(&mark)
.height(Dimension::Pct(100.0))
.flex_shrink(0.0)
.with_children(halves)
.offset(if forward { wide / 2.0 } else { -wide / 2.0 }, 0.0);
Some(
Row::new()
.size(Dimension::Pct(100.0), Dimension::Pct(100.0))
.justify(if forward { Justify::End } else { Justify::Start })
.pointer_events_none()
.describe("a11y_hidden", "true")
.child(ellipse)
.into(),
)
}
fn tap(&self) -> Arc<dyn Fn(f32) + Send + Sync> {
let player = self.player;
let (shown, hide) = (self.live.shown.clone(), self.live.hide.clone());
let (mark, unmark, tapped) = (
self.live.mark.clone(),
self.live.unmark.clone(),
self.live.tapped.clone(),
);
let (root, mounted) = (self.live.root.clone(), self.live.mounted);
let (seek, position) = (self.seeker(), player.position.value);
let seekable = !player.live || player.duration.is_some();
Arc::new(move |x: f32| {
let side: i8 = match (mounted, root.width()) {
(true, width) if width > 0.0 => match (x - root.x()) / width {
at if at < 1.0 / 3.0 => -1,
at if at > 2.0 / 3.0 => 1,
_ => 0,
},
_ => 0,
};
let now = Instant::now();
let again = {
let mut last = tapped.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
let again = matches!(*last, Some((then, was)) if side != 0 && was == side
&& now.duration_since(then) <= VIDEO_PLAYER_DOUBLE_PRESS);
*last = Some((now, side));
again
};
if again && seekable {
let forward = side > 0;
let so_far = match mark.get_untracked() {
Some((was, seconds)) if was == forward => seconds,
_ => 0,
};
mark.set(Some((forward, so_far + VIDEO_PLAYER_TAP_SEEKS as u32)));
if let Some(unmark) = &unmark {
unmark.restart();
}
seek(position + f64::from(side) * VIDEO_PLAYER_TAP_SEEKS);
if shown.get_untracked() {
shown.set(false);
}
if let Some(hide) = &hide {
hide.cancel();
}
return;
}
if shown.get_untracked() {
shown.set(false);
if let Some(hide) = &hide {
hide.cancel();
}
} else {
shown.set(true);
}
})
}
fn bar(&mut self, narrow: bool) -> VideoPlayerBar {
let player = self.player;
let seek = self.seek();
let play = self.play();
let time = self.time();
let full = player.fullscreen.value;
let fullscreen_label = if full {
player.words.exit_fullscreen.clone()
} else {
player.words.fullscreen.clone()
};
let fullscreen_icon = if full {
icons::FULLSCREEN_EXIT
} else {
icons::FULLSCREEN
};
let (volume, end, menus) = match self.form {
VideoPlayerSize::Sm => (None, Vec::new(), Vec::new()),
VideoPlayerSize::Md => {
let mute = self.mute();
let more = self.menu_button(
VideoPlayerMenu::More,
"more",
Some(icons::MORE_VERTICAL),
&player.words.more,
);
let press = self.fullscreen_toggle();
let fullscreen = self.toggle_control("fullscreen", fullscreen_icon, &fullscreen_label, "F", false, press);
(None, vec![mute, more, fullscreen], vec![self.more_menu()])
}
VideoPlayerSize::Lg => {
let volume = self.volume(narrow);
let mut end = Vec::new();
let mut menus = Vec::new();
if player.has_captions() {
let captions_on = player.captions.value;
let press = self.pressed(player.captions.teller(), !captions_on);
end.push(self.toggle_control(
"captions",
icons::CAPTIONS,
&player.words.captions,
"C",
captions_on,
press,
));
}
if !player.live {
end.push(self.menu_button(VideoPlayerMenu::Speed, "speed", None, &player.words.speed));
menus.push(self.speed_menu());
}
if self.has_settings() {
end.push(self.menu_button(
VideoPlayerMenu::Settings,
"settings",
Some(icons::SETTINGS),
&player.words.settings,
));
menus.insert(0, self.settings_menu());
}
let pip = player.picture_in_picture.value;
let press = self.pressed(player.picture_in_picture.teller(), !pip);
end.push(self.toggle_control(
"pip",
icons::PICTURE_IN_PICTURE,
&player.words.picture_in_picture,
"",
pip,
press,
));
let press = self.fullscreen_toggle();
end.push(self.toggle_control("fullscreen", fullscreen_icon, &fullscreen_label, "F", false, press));
(Some(volume), end, menus)
}
};
let height = match self
.part(VideoPlayerPart::Controls)
.rest()
.height
.and_then(|height| height.resolve(self.recipe.theme()))
{
Some(Dimension::Px(px)) => px,
_ => 0.0,
};
let volume_out =
narrow && self.form == VideoPlayerSize::Lg && self.live.volume.as_ref().is_some_and(|kept| kept.asks());
VideoPlayerBar {
seek,
play,
volume,
time,
volume_out,
end,
menus,
row: self.live.row.clone(),
buttons: self.live.buttons.clone(),
height,
}
}
fn center(&mut self) -> Option<Element> {
let player = self.player;
if let Some(title) = &player.error {
let part = self.part(VideoPlayerPart::Error);
let text = self.part(VideoPlayerPart::Text);
let title_part = self.part(VideoPlayerPart::Title);
let mut words = Column::new()
.part(&text)
.align_items(Alignment::Center)
.child(title_part.text(title).text_align(TextAlign::Center).part(&title_part));
if let Some(description) = &player.error_description {
let part = self.part(VideoPlayerPart::Description);
words = words.child(part.text(description).text_align(TextAlign::Center).part(&part));
}
return Some(
Column::new()
.part(&part)
.align_items(Alignment::Center)
.describe("a11y_role", "alert")
.child(glyph(
&self.part(VideoPlayerPart::ErrorIcon),
Name::new(icons::ALERT_CIRCLE),
false,
))
.child(words)
.into(),
);
}
if player.waiting {
return Some(
Row::new()
.describe("a11y_role", "progressbar")
.describe("a11y_busy", "true")
.child(glyph(
&self.part(VideoPlayerPart::Spinner),
Name::new(icons::SPINNER),
true,
))
.into(),
);
}
if player.playing.value && !player.ended || self.form == VideoPlayerSize::Sm {
return None;
}
let size = if self.form == VideoPlayerSize::Md {
PlayButtonSize::Lg
} else {
PlayButtonSize::Xl
};
let next = self.toggle();
let mut button = PlayButton::new()
.variant(PlayButtonVariant::Overlay)
.size(size)
.replay(player.ended)
.play_label(&player.words.play)
.replay_label(&player.words.replay)
.on_change(move |_| next());
if let Some(id) = self.id("center") {
button = button.id(id);
}
Some(button.build(self.recipe.theme()))
}
fn retry(&mut self) -> Option<Element> {
let player = self.player;
if player.error.is_none() || player.on_retry.is_empty() {
return None;
}
let part = self.part(VideoPlayerPart::Retry);
let handlers = player.on_retry.clone();
let mut button = pressable(&part, false)
.describe("a11y_role", "button")
.describe("a11y_name", player.words.retry.clone())
.child(part.text(&player.words.retry).nowrap())
.on_click(move |_| {
for handler in &handlers {
handler();
}
});
if let Some(id) = self.id("retry") {
button = button.id(id);
}
Some(button.into())
}
fn keys(&self) -> impl Fn(KeyboardEvent) + Send + Sync + 'static {
let player = self.player;
let toggle = self.toggle();
let seek = self.seeker();
let position = player.position.value;
let duration = player.duration;
let seekable = !player.live || duration.is_some();
let volume = (player.volume.value, player.volume.teller());
let muted = (player.muted.value, player.muted.teller());
let captions = (player.captions.value, player.captions.teller(), player.has_captions());
let fullscreen = self.fullscreen_toggle();
let full = player.fullscreen.value;
let buttons = self.live.buttons.clone();
let poke = self.live.mounted.then(|| self.live.poke());
let controls = player.controls && player.error.is_none();
move |event: KeyboardEvent| {
if !controls || !event.focus_within || event.ctrl || event.alt || event.meta || event.text_input_focused {
return;
}
let on_a_control = buttons.focus_visible_within() || buttons.focused();
let step = |by: f64| {
if seekable {
seek(position + by);
}
};
let handled = match event.key.as_str() {
" " if !on_a_control => {
toggle();
true
}
"k" | "K" => {
toggle();
true
}
"ArrowLeft" if !on_a_control => {
step(-VIDEO_PLAYER_SEEK_STEP);
true
}
"ArrowRight" if !on_a_control => {
step(VIDEO_PLAYER_SEEK_STEP);
true
}
"j" | "J" => {
step(-2.0 * VIDEO_PLAYER_SEEK_STEP);
true
}
"l" | "L" => {
step(2.0 * VIDEO_PLAYER_SEEK_STEP);
true
}
"Home" if !on_a_control && seekable => {
seek(0.0);
true
}
"End" if !on_a_control && seekable && duration.is_some() => {
seek(duration.unwrap_or_default());
true
}
"ArrowUp" | "ArrowDown" if !on_a_control => {
let by = if event.key == "ArrowUp" {
VIDEO_PLAYER_VOLUME_STEP
} else {
-VIDEO_PLAYER_VOLUME_STEP
};
(volume.1)(((volume.0 + by) * 100.0).round().clamp(0.0, 100.0) / 100.0);
true
}
"m" | "M" => {
(muted.1)(!muted.0);
true
}
"c" | "C" if captions.2 => {
(captions.1)(!captions.0);
true
}
"f" | "F" => {
fullscreen();
true
}
"Escape" if full => {
fullscreen();
true
}
_ => false,
};
if handled {
event.prevent_default();
if let Some(poke) = &poke {
poke();
}
}
}
}
}
pub struct VideoPlayerView {
pub form: VideoPlayerSize,
pub narrow: bool,
pub controls: bool,
pub bar_shown: bool,
pub poster_shown: bool,
pub playing: bool,
pub waiting: bool,
pub ended: bool,
pub live: bool,
pub duration: Option<f64>,
pub error: Option<Arc<str>>,
pub error_description: Option<Arc<str>>,
pub caption: Option<Arc<str>>,
pub label: Arc<str>,
pub width: Option<Length>,
pub height: Option<Length>,
pub max_width: Option<Length>,
pub aspect: f32,
pub media: Option<Element>,
pub poster: Option<Element>,
pub children: Vec<Element>,
pub bar: Option<VideoPlayerBar>,
pub center: Option<Element>,
pub retry: Option<Element>,
pub recipe: ResolvedRecipe,
keys: Arc<dyn Fn(KeyboardEvent) + Send + Sync>,
pub touch: Option<VideoPlayerTouch>,
tap: Option<Arc<dyn Fn(f32) + Send + Sync>>,
toggle: Action,
fullscreen: Action,
pressed: Arc<Mutex<Option<Instant>>>,
poke: Option<Action>,
root: ElementRef,
mounted: bool,
tooling: Vec<(&'static str, Arc<str>)>,
filling: bool,
id: Option<Arc<str>>,
}
impl VideoPlayerView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
fn id(&self, suffix: &str) -> Option<String> {
self.id.as_ref().map(|id| format!("{id}-{suffix}"))
}
fn render_themed(self) -> Element {
match self.theme().renderer::<VideoPlayer>() {
Some(renderer) => renderer(self),
None => self.render(),
}
}
fn layer() -> Stack {
Stack::new().size(Dimension::Pct(100.0), Dimension::Pct(100.0))
}
pub fn root(&self) -> Stack {
let theme = self.theme();
let mut root = Stack::new()
.part(&self.part(VideoPlayerPart::Root))
.focusable(true)
.tab_index(-1)
.describe("a11y_role", "group")
.describe("a11y_name", self.label.clone());
for (name, said) in &self.tooling {
root = root.describe(*name, said.clone());
}
if self.mounted {
root = root.ref_element(self.root.clone());
}
if self.filling {
root = root.rounded(0.0);
}
let width = self.width.and_then(|width| width.resolve(theme));
if let Some(width) = width {
root = root.width(width);
}
if let Some(most) = self.max_width.and_then(|width| width.resolve(theme)) {
root = root.max_width(most);
}
match (self.height.and_then(|height| height.resolve(theme)), width) {
(Some(height), _) => root = root.height(height),
(None, Some(Dimension::Px(width))) => root = root.height(shaped(width, self.aspect)),
_ => {}
}
if self.controls {
let keys = self.keys.clone();
root = root.on_key_down(move |event: KeyboardEvent| keys(event));
}
if let Some(poke) = self.poke.clone() {
root = root.on_mouse_move(move |_| poke());
}
if let Some(id) = &self.id {
root = root.id(id.clone());
}
root
}
pub fn media(&self) -> Stack {
let mut layer = Self::layer().part(&self.part(VideoPlayerPart::Media));
if let Some(media) = &self.media {
layer = layer.child(Self::layer().child(media.clone()));
}
if let Some(poster) = &self.poster {
layer = layer.child(Self::layer().child(poster.clone()));
}
if let Some(tap) = self.tap.clone() {
layer = layer.on_click(move |event: MouseEvent| tap(event.x));
} else if self.controls && self.error.is_none() {
let (toggle, fullscreen, pressed) = (self.toggle.clone(), self.fullscreen.clone(), self.pressed.clone());
layer = layer.on_click(move |event: MouseEvent| {
toggle();
let now = event.time;
let mut last = pressed.lock().unwrap_or_else(|poisoned| poisoned.into_inner());
match last.take() {
Some(then) if now.duration_since(then) <= VIDEO_PLAYER_DOUBLE_PRESS => fullscreen(),
_ => *last = Some(now),
}
});
}
layer
}
pub fn veil(&self) -> Option<Stack> {
(self.controls && (self.ended || self.error.is_some())).then(|| {
Self::layer()
.part(&self.part(VideoPlayerPart::Veil))
.pointer_events_none()
})
}
pub fn overlay(&self) -> Stack {
let mut layer = Self::layer()
.part(&self.part(VideoPlayerPart::Overlay))
.hit_test(HitTestBehavior::ContentOnly)
.with_children(self.children.iter().cloned());
if let Some(id) = self.id("overlay") {
layer = layer.id(id);
}
layer
}
pub fn center(&self) -> Option<Column> {
let center = self.center.clone()?;
let mut middle = Column::new()
.part(&self.part(VideoPlayerPart::Center).unnamed())
.size(Dimension::Pct(100.0), Dimension::Pct(100.0))
.align_items(Alignment::Center)
.justify(Justify::Center)
.hit_test(HitTestBehavior::ContentOnly)
.child(center);
if let Some(retry) = &self.retry {
middle = middle.child(retry.clone());
}
Some(middle)
}
pub fn captions(&self) -> Option<Column> {
let caption = self.caption.as_ref()?;
let part = self.part(VideoPlayerPart::Caption);
let mut line = Column::new()
.part(&part)
.align_items(Alignment::Center)
.child(part.text(caption).text_align(TextAlign::Center));
if let Some(id) = self.id("caption") {
line = line.id(id);
}
let down = match &self.bar {
Some(bar) if !self.bar_shown => bar.height,
_ => 0.0,
};
Some(
Column::new()
.part(&self.part(VideoPlayerPart::Captions).unnamed())
.width(Dimension::Pct(100.0))
.align_items(Alignment::Center)
.pointer_events_none()
.offset(0.0, down)
.child(line),
)
}
pub fn chip(&self) -> Option<Row> {
let duration = self
.duration
.filter(|_| self.controls && self.poster_shown && !self.live)?;
let value = self.part(VideoPlayerPart::ChipValue);
Some(
Row::new()
.part(&self.part(VideoPlayerPart::Chip))
.width(Dimension::Pct(100.0))
.justify(Justify::End)
.pointer_events_none()
.child(
Row::new()
.part(&value)
.child(value.text(&media_time_text(duration, false)).nowrap()),
),
)
}
pub fn bar(&self) -> Option<Column> {
let bar = self.bar.as_ref()?;
let part = self.part(VideoPlayerPart::Controls);
let rest = part.rest();
let end = rest
.background
.clone()
.unwrap_or(crate::node::BackgroundColor::Color(Color::new(0, 0, 0, 0xB3)));
let clear = crate::node::BackgroundColor::Color(Color::new(0, 0, 0, 0));
let mut controls = Column::new()
.part(&part)
.width(Dimension::Pct(100.0))
.align_items(Alignment::Stretch)
.justify(Justify::End)
.overflow_visible()
.background_gradient(crate::node::Gradient::linear(180.0, [(clear, 0.0), (end, 1.0)].map(
|(color, at)| crate::node::gradient::GradientStop::at(color, at),
)));
if let Some(id) = self.id("controls") {
controls = controls.id(id);
}
let row_part = self.part(VideoPlayerPart::Row);
let mut row = Row::new()
.part(&row_part)
.width(Dimension::Pct(100.0))
.align_items(Alignment::Center)
.overflow_visible();
let mounted = self.mounted;
if mounted {
row = row.ref_element(bar.row.clone());
}
let held = |row: Row| {
if mounted {
row.ref_element(bar.buttons.clone())
} else {
row
}
};
let buttons = |children: Vec<Element>| {
Row::new()
.align_items(Alignment::Center)
.spacing(row_part.rest().gap.unwrap_or_default())
.overflow_visible()
.with_children(children)
};
if self.form == VideoPlayerSize::Sm {
row = row
.child(held(buttons(vec![bar.play.clone()])))
.child(Row::new().flex(1.0).min_width(0.0).child(bar.seek.clone()))
.child(bar.time.clone());
return Some(controls.child(row).with_children(bar.menus.iter().cloned()));
}
let mut start = vec![bar.play.clone()];
start.extend(bar.volume.clone());
if !bar.volume_out {
start.push(bar.time.clone());
}
let mut all = buttons(start);
all = all.child(Row::new().flex(1.0));
all = all.with_children(bar.end.iter().cloned());
row = row.child(held(all.flex(1.0)));
Some(
controls
.child(bar.seek.clone())
.child(row)
.with_children(bar.menus.iter().cloned()),
)
}
fn render_touch(&self, touch: &VideoPlayerTouch) -> Element {
let shown = self.bar_shown && self.error.is_none();
let mut root = self.root().child(self.media());
if let Some(veil) = self.veil() {
root = root.child(veil);
}
if shown {
root = root.child(
Self::layer()
.part(&self.part(VideoPlayerPart::Scrim))
.pointer_events_none(),
);
}
root = root.child(self.overlay());
if let Some(mark) = &touch.mark {
root = root.child(mark.clone());
}
if let Some(center) = self.center() {
root = root.child(center);
}
if shown && let Some(transport) = &touch.transport {
root = root.child(
Column::new()
.size(Dimension::Pct(100.0), Dimension::Pct(100.0))
.align_items(Alignment::Center)
.justify(Justify::Center)
.hit_test(HitTestBehavior::ContentOnly)
.child(transport.clone()),
);
}
let mut edges = Column::new()
.size(Dimension::Pct(100.0), Dimension::Pct(100.0))
.justify(Justify::SpaceBetween)
.align_items(Alignment::Stretch)
.overflow_visible()
.hit_test(HitTestBehavior::ContentOnly);
let mut bottom = Column::new()
.width(Dimension::Pct(100.0))
.align_items(Alignment::Stretch)
.overflow_visible();
if let Some(captions) = self.captions() {
bottom = bottom.child(captions);
}
if shown {
let mut top = Row::new()
.part(&self.part(VideoPlayerPart::Top))
.width(Dimension::Pct(100.0))
.align_items(Alignment::Center)
.overflow_visible();
if self.mounted {
top = top.ref_element(touch.top.clone());
}
if let Some(lead) = &touch.lead {
top = top.child(lead.clone());
}
top = top.child(match &touch.heading {
Some(heading) => Row::new().flex(1.0).min_width(0.0).clip().child(heading.clone()),
None => Row::new().flex(1.0),
});
top = top.with_children(touch.tools.iter().cloned());
let mut foot = Row::new()
.part(&self.part(VideoPlayerPart::Foot))
.width(Dimension::Pct(100.0))
.align_items(Alignment::Center)
.overflow_visible();
if self.mounted {
foot = foot.ref_element(touch.row.clone());
}
foot = foot
.child(touch.time.clone())
.child(Row::new().flex(1.0))
.with_children(touch.foot.iter().cloned());
let rail = Row::new()
.part(&self.part(VideoPlayerPart::Rail))
.width(Dimension::Pct(100.0))
.overflow_visible()
.child(touch.seek.clone());
let mut controls = bottom.child(foot).child(rail);
if let Some(id) = self.id("controls") {
controls = controls.id(id);
}
edges = edges.child(top).child(controls);
} else {
edges = edges.child(Row::new()).child(bottom);
}
root
.child(edges.with_children(touch.menus.iter().filter(|_| shown).cloned()))
.into()
}
pub fn render(self) -> Element {
if let Some(touch) = &self.touch {
return self.render_touch(touch);
}
let mut root = self.root().child(self.media());
if let Some(veil) = self.veil() {
root = root.child(veil);
}
root = root.child(self.overlay());
if let Some(center) = self.center() {
root = root.child(center);
}
let mut bottom = Column::new()
.size(Dimension::Pct(100.0), Dimension::Pct(100.0))
.justify(Justify::End)
.align_items(Alignment::Stretch)
.overflow_visible()
.hit_test(HitTestBehavior::ContentOnly);
if let Some(captions) = self.captions() {
bottom = bottom.child(captions);
}
if let Some(chip) = self.chip() {
bottom = bottom.child(chip);
}
if let Some(bar) = self.bar() {
bottom = bottom.child(bar);
}
root.child(bottom).into()
}
}
impl crate::ui::Styled for VideoPlayer {
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 VideoPlayer {
const NAME: &'static str = "video_player";
type Renderer = VideoPlayerRenderer;
fn parts() -> crate::ui::Declared {
VideoPlayerPart::declared()
}
fn states() -> crate::ui::Declared {
VideoPlayerState::declared()
}
fn recipe() -> Recipe {
use VideoPlayerPart::*;
use VideoPlayerSize::{Md, Sm};
let white = Color::new(255, 255, 255, 255);
let white_60 = Color::new(255, 255, 255, 0x99);
let white_20 = Color::new(255, 255, 255, 0x33);
let white_12 = Color::new(255, 255, 255, 0x1F);
let black_60 = Color::new(0, 0, 0, 0x99);
let black_70 = Color::new(0, 0, 0, 0xB3);
let ink = Color::new(0x18, 0x18, 0x1B, 255);
let ring = move |s: super::PartStyle| s.outline(Outline::new(2.0, white));
Recipe::new()
.base(Root, |s| {
s.width(640.0)
.height(360.0)
.radius(RadiusSize::Lg)
.background(Color::new(0, 0, 0, 255))
.foreground(white)
})
.size(Md, Root, |s| s.width(320.0).height(180.0))
.size(Sm, Root, |s| s.width(200.0).height(113.0))
.base(Media, |s| s.cursor(CursorIcon::Pointer))
.state(VideoPlayerState::Bare, Media, |s| s.cursor(CursorIcon::Default))
.state(VideoPlayerState::Error, Media, |s| s.cursor(CursorIcon::Default))
.state(VideoPlayerState::Hidden, Root, |s| s.cursor(CursorIcon::None))
.state(VideoPlayerState::Hidden, Media, |s| s.cursor(CursorIcon::None))
.base(Veil, |s| s.background(black_60))
.state(VideoPlayerState::Touch, Root, |s| s.radius(0.0))
.base(Scrim, |s| s.background(Color::new(0, 0, 0, 0x66)))
.base(Top, |s| s.height(44.0).padding_x(4.0))
.state(VideoPlayerState::Landscape, Top, |s| s.height(52.0).padding_top(8.0).padding_x(44.0).gap(4.0))
.base(Heading, |s| s.padding_x(8.0))
.state(VideoPlayerState::Landscape, Title, |s| s.font_size(16.0).weight(FontWeight::SemiBold))
.base(Line, |s| {
s.typography(TypographyStyle::Body).font_size(13.0).foreground(white_60)
})
.base(Touch, |s| {
fading(
s.square(44.0)
.radius(RadiusSize::Full)
.foreground(white)
.cursor(CursorIcon::Pointer),
)
})
.hovered(Touch, |s| s.background(white_12))
.pressed(Touch, |s| s.background(white_20))
.focus_visible(Touch, ring)
.state(VideoPlayerState::On, Touch, |s| s.background(white_20))
.base(TouchIcon, |s| s.square(24.0))
.base(Transport, |s| s.gap(32.0))
.state(VideoPlayerState::Landscape, Transport, |s| s.gap(56.0))
.base(Skip, |s| {
fading(
s.square(44.0)
.radius(RadiusSize::Full)
.foreground(white)
.cursor(CursorIcon::Pointer),
)
})
.state(VideoPlayerState::Landscape, Skip, |s| s.square(48.0))
.hovered(Skip, |s| s.background(white_12))
.pressed(Skip, |s| s.background(white_20))
.focus_visible(Skip, ring)
.base(SkipIcon, |s| s.square(28.0))
.state(VideoPlayerState::Landscape, SkipIcon, |s| s.square(32.0))
.base(Disc, |s| {
fading(
s.square(56.0)
.radius(RadiusSize::Full)
.background(Color::new(0, 0, 0, 0x66))
.foreground(white)
.cursor(CursorIcon::Pointer),
)
})
.state(VideoPlayerState::Landscape, Disc, |s| s.square(72.0))
.hovered(Disc, |s| s.background(black_60))
.pressed(Disc, |s| s.background(black_70))
.focus_visible(Disc, ring)
.base(DiscIcon, |s| s.square(32.0))
.state(VideoPlayerState::Landscape, DiscIcon, |s| s.square(36.0))
.base(Foot, |s| s.height(44.0).padding_start(16.0).padding_end(4.0))
.state(VideoPlayerState::Landscape, Foot, |s| s.padding_start(56.0).padding_end(44.0).gap(4.0))
.base(Pill, |s| {
fading(
s.height(44.0)
.min_width(44.0)
.padding_x(12.0)
.radius(RadiusSize::Full)
.foreground(white)
.typography(TypographyStyle::Body)
.font_size(15.0)
.weight(FontWeight::Medium)
.cursor(CursorIcon::Pointer),
)
})
.hovered(Pill, |s| s.background(white_12))
.pressed(Pill, |s| s.background(white_20))
.focus_visible(Pill, ring)
.state(VideoPlayerState::On, Pill, |s| s.background(white_20))
.base(Rail, |s| s.padding_x(16.0).padding_bottom(6.0))
.state(VideoPlayerState::Landscape, Rail, |s| s.padding_x(56.0).padding_bottom(12.0))
.base(Mark, |s| s.width(288.0).radius(RadiusSize::Full).background(white_20).gap(4.0))
.base(MarkIcon, |s| s.square(28.0).foreground(white))
.base(MarkText, |s| {
s.typography(TypographyStyle::Body)
.font_size(13.0)
.weight(FontWeight::Medium)
.foreground(white)
})
.base(Center, |s| s.gap(8.0))
.base(Spinner, |s| s.square(32.0).foreground(white))
.base(Error, |s| s.gap(12.0).padding_x(24.0).max_width(360.0))
.base(ErrorIcon, |s| s.square(24.0).foreground(white))
.base(Text, |s| s.gap(4.0))
.base(Title, |s| {
s.typography(TypographyStyle::Body)
.font_size(14.0)
.weight(FontWeight::Medium)
.foreground(white)
})
.base(Description, |s| {
s.typography(TypographyStyle::Body).font_size(13.0).foreground(white_60)
})
.base(Retry, |s| {
fading(
s.height(32.0)
.padding_x(12.0)
.radius(RadiusSize::Md)
.background(white)
.foreground(ink)
.typography(TypographyStyle::Body)
.font_size(14.0)
.weight(FontWeight::Medium)
.cursor(CursorIcon::Pointer),
)
})
.hovered(Retry, |s| s.background(Color::new(255, 255, 255, 0xE6)))
.focus_visible(Retry, |s| s.outline(Outline::new(2.0, white).offset(2.0)))
.base(Captions, |s| {
s.padding_x(24.0)
.padding_bottom(12.0)
.transition(PartTransition::new(Transition::offset_y(), MotionDuration::Base).easing(MotionEasing::Enter))
})
.state(VideoPlayerState::Hidden, Captions, |s| {
s.transition(PartTransition::new(Transition::offset_y(), MotionDuration::Slow).easing(MotionEasing::Exit))
})
.base(Caption, |s| {
s.padding_x(8.0)
.padding_y(2.0)
.radius(RadiusSize::Sm)
.background(black_70)
.foreground(white)
.typography(TypographyStyle::Body)
.font_size(16.0)
.weight(FontWeight::Medium)
.line_height(1.4)
})
.base(Chip, |s| s.padding_x(12.0).padding_bottom(12.0))
.base(ChipValue, |s| {
s.padding_x(6.0)
.padding_y(2.0)
.radius(RadiusSize::Sm)
.background(black_70)
.foreground(white)
.typography(TypographyStyle::Mono)
.font_size(11.0)
})
.base(Controls, |s| {
s.height(88.0)
.padding_top(24.0)
.padding_x(12.0)
.padding_bottom(8.0)
.gap(4.0)
.background(black_70)
.opacity(1.0)
.transition(PartTransition::new(Transition::opacity(), MotionDuration::Base).easing(MotionEasing::Enter))
})
.size(Md, Controls, |s| {
s.height(72.0).padding_top(20.0).padding_x(8.0).padding_bottom(6.0).gap(2.0)
})
.size(Sm, Controls, |s| {
s.height(48.0)
.padding_top(16.0)
.padding_start(4.0)
.padding_end(8.0)
.padding_bottom(4.0)
.gap(0.0)
})
.state(VideoPlayerState::Hidden, Controls, |s| {
s.opacity(0.0)
.transition(PartTransition::new(Transition::opacity(), MotionDuration::Slow).easing(MotionEasing::Exit))
})
.base(Row, |s| s.height(36.0).gap(4.0))
.size(Md, Row, |s| s.height(28.0).gap(2.0))
.size(Sm, Row, |s| s.height(28.0).gap(6.0))
.base(Control, |s| {
fading(
s.square(36.0)
.radius(RadiusSize::Md)
.foreground(white)
.cursor(CursorIcon::Pointer),
)
})
.size(Md, Control, |s| s.square(28.0))
.size(Sm, Control, |s| s.square(28.0))
.hovered(Control, |s| s.background(white_12))
.focus_visible(Control, ring)
.state(VideoPlayerState::On, Control, |s| s.background(white_20))
.when(Selector::new().state(VideoPlayerState::On).hovered(), Control, |s| {
s.background(white_20)
})
.base(ControlIcon, |s| s.square(20.0))
.size(Md, ControlIcon, |s| s.square(16.0))
.size(Sm, ControlIcon, |s| s.square(16.0))
.base(Speed, |s| {
fading(
s.height(36.0)
.padding_x(10.0)
.radius(RadiusSize::Md)
.foreground(white)
.typography(TypographyStyle::Body)
.font_size(13.0)
.weight(FontWeight::Medium)
.cursor(CursorIcon::Pointer),
)
})
.hovered(Speed, |s| s.background(white_12))
.focus_visible(Speed, ring)
.state(VideoPlayerState::On, Speed, |s| s.background(white_20))
.when(Selector::new().state(VideoPlayerState::On).hovered(), Speed, |s| {
s.background(white_20)
})
.base(Time, |s| s.padding_x(8.0).foreground(white))
.size(Md, Time, |s| s.padding_x(6.0))
.size(Sm, Time, |s| s.padding_x(0.0))
.base(Elapsed, |s| s.typography(TypographyStyle::Mono).font_size(11.0).foreground(white))
.base(Menus, |s| s.gap(24.0))
.size(Md, Menus, |s| s.gap(22.0))
.base(SettingsMenu, |s| s.width(240.0).min_width(240.0))
.base(MoreMenu, |s| s.width(200.0).min_width(200.0))
.base(MenuValue, |s| s.typography(TypographyStyle::Body).font_size(13.0))
}
}