use std::{
sync::{
Arc,
atomic::{AtomicBool, AtomicUsize, Ordering},
},
time::Duration,
};
use parking_lot::Mutex;
use super::{
Button, ButtonPart, ButtonShape, ButtonVariant, icons, names,
part_style::Length,
recipe::{Case, Name, Recipe, ResolvedPart, ResolvedRecipe},
shared::{fading, pressable},
theme::{Themed, current_theme},
};
use crate::{
app::{
component::Component,
ctx::{Ctx, Interval, Timeout},
events::{DragEvent, KeyboardEvent, MouseEvent, ScrollEvent},
theme::{OpacityLevel, PaletteColor, RadiusSize, Theme},
},
components::{Column, Row, ScrollHorizontal},
core::{ElementRef, Signal},
layout::{Alignment, layout_kind::ScrollState, scrollbar::ScrollBarStyle},
node::{CursorIcon, Element, FocusGroup, NodeUpdate, dimension::Dimension},
};
const DRAG_TURNS_AT: f32 = 0.2;
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum CarouselPart {
Root,
Track,
Viewport,
Slide,
Arrow,
Dots,
Dot,
DotMark,
}
names!(CarouselPart {
Root => "root",
Track => "track",
Viewport => "viewport",
Slide => "slide",
Arrow => "arrow",
Dots => "dots",
Dot => "dot",
DotMark => "dot_mark",
});
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub enum CarouselState {
Current,
Disabled,
}
names!(CarouselState {
Current => "current",
Disabled => "disabled",
});
pub type CarouselRenderer = Arc<dyn Fn(CarouselView) -> Element + Send + Sync>;
type Action = Arc<dyn Fn() + Send + Sync>;
type Told<T> = Arc<dyn Fn(T) + Send + Sync>;
type Said = Arc<dyn Fn(usize, usize) -> String + Send + Sync>;
#[derive(Clone)]
struct Words {
label: Arc<str>,
previous: Arc<str>,
next: Arc<str>,
}
impl Default for Words {
fn default() -> Self {
let locale = super::current_locale();
Self {
label: locale.navigation.carousel.clone(),
previous: locale.navigation.previous_slide.clone(),
next: locale.navigation.next_slide.clone(),
}
}
}
#[derive(Clone)]
pub struct Carousel {
slides: Vec<Element>,
index: Option<Signal<usize>>,
controlled: Option<usize>,
on_index_change: Vec<Told<usize>>,
per_view: usize,
gap: f32,
wrap: bool,
arrows: bool,
dots: bool,
autoplay: Option<Duration>,
width: Option<Length>,
disabled: bool,
words: Words,
slide_label: Option<Said>,
states: Vec<Name>,
rules: Recipe,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl Carousel {
pub fn new(slides: impl IntoIterator<Item = impl Into<Element>>) -> Self {
Self {
slides: slides.into_iter().map(Into::into).collect(),
index: None,
controlled: None,
on_index_change: Vec::new(),
per_view: 1,
gap: 12.0,
wrap: false,
arrows: true,
dots: true,
autoplay: None,
width: None,
disabled: false,
words: Words::default(),
slide_label: None,
states: Vec::new(),
rules: Recipe::new(),
id: None,
key: None,
}
}
pub fn slide(mut self, slide: impl Into<Element>) -> Self {
self.slides.push(slide.into());
self
}
pub fn slides(mut self, slides: impl IntoIterator<Item = impl Into<Element>>) -> Self {
self.slides.extend(slides.into_iter().map(Into::into));
self
}
pub fn index(mut self, index: Signal<usize>) -> Self {
self.index = Some(index);
self
}
pub fn index_controlled(mut self, index: usize, on_change: impl Fn(usize) + Send + Sync + 'static) -> Self {
self.controlled = Some(index);
self.on_index_change.push(Arc::new(on_change));
self
}
pub fn on_index_change(mut self, handler: impl Fn(usize) + Send + Sync + 'static) -> Self {
self.on_index_change.push(Arc::new(handler));
self
}
pub fn per_view(mut self, per_view: usize) -> Self {
self.per_view = per_view.max(1);
self
}
pub fn gap(mut self, gap: f32) -> Self {
self.gap = gap.max(0.0);
self
}
pub fn wrap(mut self, wrap: bool) -> Self {
self.wrap = wrap;
self
}
pub fn arrows(mut self, arrows: bool) -> Self {
self.arrows = arrows;
self
}
pub fn dots(mut self, dots: bool) -> Self {
self.dots = dots;
self
}
pub fn autoplay(mut self, every: Duration) -> Self {
self.autoplay = Some(every);
self
}
pub fn width(mut self, width: impl Into<Length>) -> Self {
self.width = Some(width.into());
self
}
pub fn disabled(mut self, disabled: bool) -> Self {
self.disabled = disabled;
self
}
pub fn label(mut self, label: &str) -> Self {
self.words.label = Arc::from(label);
self
}
pub fn previous_label(mut self, label: &str) -> Self {
self.words.previous = Arc::from(label);
self
}
pub fn next_label(mut self, label: &str) -> Self {
self.words.next = Arc::from(label);
self
}
pub fn slide_label(mut self, label: impl Fn(usize, usize) -> String + Send + Sync + 'static) -> Self {
self.slide_label = Some(Arc::new(label));
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 id(mut self, id: impl Into<Arc<str>>) -> Self {
self.id = Some(id.into());
self
}
pub fn key(mut self, key: impl Into<Arc<str>>) -> Self {
self.key = Some(key.into());
self
}
pub fn mount(self, ctx: &mut Ctx) -> Element {
let key = self.key.clone();
let props = CarouselProps(self);
match key {
Some(key) => ctx.mount_keyed::<CarouselHost>(&key, props),
None => ctx.mount::<CarouselHost>(props),
}
}
fn name_of(&self, at: usize, count: usize) -> String {
match &self.slide_label {
Some(label) => label(at, count),
None => crate::core::fill(
&super::current_locale().navigation.slide_of,
&[("at", &at.to_string()), ("total", &count.to_string())],
),
}
}
}
impl From<Carousel> for Element {
fn from(carousel: Carousel) -> Self {
let key = carousel.key.clone();
let props = CarouselProps(carousel);
match key {
Some(key) => Element::component_keyed::<CarouselHost>(key, props),
None => Element::component::<CarouselHost>(props),
}
}
}
#[derive(Clone)]
struct CarouselProps(Carousel);
impl PartialEq for CarouselProps {
fn eq(&self, _: &Self) -> bool {
false
}
}
impl crate::app::component::DevtoolsInspectable for CarouselProps {}
struct CarouselHost {
index: Signal<usize>,
scroll: ScrollState,
viewport: ElementRef,
root: ElementRef,
room: Signal<f32>,
placed: Arc<Mutex<Option<(usize, f32)>>>,
settle: Signal<u64>,
settle_wanted: Arc<AtomicBool>,
stopped: Arc<AtomicBool>,
timer: Mutex<Option<Interval>>,
advance: Arc<Mutex<Option<Action>>>,
dragged_from: Arc<Mutex<usize>>,
current: Arc<AtomicUsize>,
arrows: [ElementRef; 2],
rest: Timeout,
resting: Arc<Mutex<Option<Action>>>,
}
const REST_AFTER: Duration = Duration::from_millis(180);
impl Component for CarouselHost {
type Props = CarouselProps;
fn create(ctx: &mut Ctx) -> Self {
let scroll = ScrollState::new();
scroll.set_paging(true);
let resting: Arc<Mutex<Option<Action>>> = Arc::default();
let rest = {
let resting = resting.clone();
ctx.create_timeout(REST_AFTER, move || {
let rest = resting.lock().clone();
if let Some(rest) = rest {
rest();
}
})
};
Self {
index: ctx.signal(0),
scroll,
viewport: ElementRef::new(),
root: ElementRef::new(),
room: ctx.signal(0.0),
placed: Arc::default(),
settle: ctx.signal(0),
settle_wanted: Arc::default(),
stopped: Arc::default(),
timer: Mutex::new(None),
advance: Arc::default(),
dragged_from: Arc::default(),
current: Arc::default(),
arrows: [ElementRef::new(), ElementRef::new()],
rest,
resting,
}
}
fn render(&self, ctx: &mut Ctx) -> impl Into<Element> {
let carousel = ctx.props::<CarouselProps>().0.clone();
let theme = current_theme();
let count = carousel.slides.len();
let shown = carousel.per_view.min(count.max(1));
let places = count.saturating_sub(shown) + 1;
let index_signal = carousel.index.clone().unwrap_or_else(|| self.index.clone());
let index = carousel
.controlled
.unwrap_or_else(|| index_signal.get())
.min(places - 1);
let _ = self.settle.get();
self.current.store(index, Ordering::Relaxed);
let room = self.room.get();
let step = if room > 0.0 {
(room + carousel.gap) / shown as f32
} else {
0.0
};
if step > 0.0 {
let mut placed = self.placed.lock();
let settle = self.settle_wanted.swap(false, Ordering::Relaxed);
let to = index as f32 * step;
match *placed {
Some((at, was)) if (was - step).abs() < 0.25 => {
if at != index || settle {
ctx.scroll_state_to(&self.scroll, to, 0.0);
}
}
_ => self.scroll.set_scroll_pending(to, 0.0),
}
*placed = Some((index, step));
}
let tell = {
let (signal, controlled, told) = (
index_signal.clone(),
carousel.controlled.is_some(),
carousel.on_index_change.clone(),
);
move |to: usize| {
if !controlled {
signal.set(to);
}
told.iter().for_each(|tell| tell(to));
}
};
let turn: Told<usize> = {
let (tell, stopped, disabled) = (tell.clone(), self.stopped.clone(), carousel.disabled);
Arc::new(move |to: usize| {
stopped.store(true, Ordering::Relaxed);
if disabled || to >= places || to == index {
return;
}
tell(to);
})
};
*self.advance.lock() = (places > 1).then(|| {
let tell = tell.clone();
let next = if index + 1 < places { index + 1 } else { 0 };
Arc::new(move || tell(next)) as Action
});
self.autoplay(ctx, &carousel, places);
let scrolled: Arc<dyn Fn() + Send + Sync> = {
let (scroll, placed, tell) = (self.scroll.clone(), self.placed.clone(), tell.clone());
Arc::new(move || {
let mut placed = placed.lock();
let Some((at, step)) = *placed else {
return;
};
if step <= 0.0 {
return;
}
let (going, _) = scroll.scroll_target();
let near = ((going / step).round().max(0.0) as usize).min(places - 1);
if near != at {
*placed = Some((near, step));
drop(placed);
tell(near);
}
})
};
let settle: Action = {
let (wanted, signal) = (self.settle_wanted.clone(), self.settle.clone());
Arc::new(move || {
wanted.store(true, Ordering::Relaxed);
signal.set(signal.get_untracked().wrapping_add(1));
})
};
let rest: Action = {
let (scrolled, settle) = (scrolled.clone(), settle.clone());
Arc::new(move || {
scrolled();
settle();
})
};
*self.resting.lock() = Some(rest.clone());
let scrolled: Action = {
let (scrolled, rest, scroll) = (scrolled.clone(), self.rest.clone(), self.scroll.clone());
Arc::new(move || {
scrolled();
let (going, _) = scroll.scroll_target();
if (going - scroll.scroll_x()).abs() < 0.5 {
rest.restart();
}
})
};
let dragged: Dragged = {
let (from, placed, scroll, stopped, current) = (
self.dragged_from.clone(),
self.placed.clone(),
self.scroll.clone(),
self.stopped.clone(),
self.current.clone(),
);
let (tell, settle) = (tell.clone(), settle.clone());
Dragged {
start: Arc::new({
let (from, current) = (from.clone(), current.clone());
move || {
stopped.store(true, Ordering::Relaxed);
*from.lock() = current.load(Ordering::Relaxed);
}
}),
moved: Arc::new(move |by: f32| scroll.scroll_by(-by, 0.0)),
end: Arc::new(move |by: f32| {
let start = *from.lock();
let step = placed.lock().map_or(0.0, |(_, step)| step);
let far = step > 0.0 && by.abs() > step * DRAG_TURNS_AT;
let to = match (far, by < 0.0) {
(true, true) => (start + 1).min(places - 1),
(true, false) => start.saturating_sub(1),
(false, _) => start,
};
if let Some(placed) = placed.lock().as_mut() {
placed.0 = usize::MAX;
}
if to != current.load(Ordering::Relaxed) {
tell(to);
}
settle();
}),
}
};
if !carousel.wrap && places > 1 {
let [before, after] = &self.arrows;
if index == 0 && before.focused() {
ctx.focus(after);
} else if index == places - 1 && after.focused() {
ctx.focus(before);
}
}
let case = |current: bool| {
Case {
variant: None,
size: None,
density: None,
breakpoint: super::current_breakpoint(),
states: carousel.states.clone(),
}
.state(CarouselState::Disabled, carousel.disabled)
.state(CarouselState::Current, current)
};
let recipe = theme
.resolve::<Carousel>(&case(false), Some(&carousel.rules))
.owned_by(carousel.id.as_ref());
let current = theme
.resolve::<Carousel>(&case(true), Some(&carousel.rules))
.owned_like(&recipe);
let view = CarouselView {
recipe,
current,
index,
places,
shown,
step,
turn,
scrolled,
settle: rest,
dragged,
scroll: self.scroll.clone(),
viewport: self.viewport.clone(),
root: self.root.clone(),
arrows: self.arrows.clone(),
carousel,
};
match theme.renderer::<Carousel>() {
Some(renderer) => renderer(view),
None => view.render(),
}
}
fn after_layout(&self) {
if !self.viewport.is_attached() {
return;
}
let room = self.viewport.width();
if (self.room.get_untracked() - room).abs() > 0.25 {
self.room.set(room);
}
}
}
impl CarouselHost {
fn autoplay(&self, ctx: &mut Ctx, carousel: &Carousel, places: usize) {
let mut timer = self.timer.lock();
match carousel.autoplay {
Some(every) if places > 1 && !carousel.disabled => {
if timer.is_none() {
let (stopped, root, advance) = (self.stopped.clone(), self.root.clone(), self.advance.clone());
let interval = ctx.create_interval(every, move || {
if stopped.load(Ordering::Relaxed) || root.hovered() || root.focus_visible_within() {
return;
}
let advance = advance.lock().clone();
if let Some(advance) = advance {
advance();
}
});
interval.start();
*timer = Some(interval);
}
}
_ => {
if let Some(interval) = timer.take() {
interval.stop();
}
}
}
}
}
#[derive(Clone)]
struct Dragged {
start: Action,
moved: Told<f32>,
end: Told<f32>,
}
pub struct CarouselView {
pub recipe: ResolvedRecipe,
current: ResolvedRecipe,
pub index: usize,
pub places: usize,
pub shown: usize,
pub step: f32,
turn: Told<usize>,
scrolled: Action,
settle: Action,
dragged: Dragged,
scroll: ScrollState,
viewport: ElementRef,
root: ElementRef,
arrows: [ElementRef; 2],
carousel: Carousel,
}
impl CarouselView {
pub fn part(&self, part: impl Into<Name>) -> ResolvedPart {
self.recipe.part(part)
}
pub fn theme(&self) -> &Theme {
self.recipe.theme()
}
fn id(&self, part: &str) -> Option<String> {
self.carousel.id.as_ref().map(|id| format!("{id}-{part}"))
}
fn neighbours(&self) -> (Option<usize>, Option<usize>) {
let (index, last, wrap) = (self.index, self.places - 1, self.carousel.wrap && self.places > 1);
let before = match index {
0 if wrap => Some(last),
0 => None,
_ => Some(index - 1),
};
let after = match index == last {
true if wrap => Some(0),
true => None,
false => Some(index + 1),
};
(before, after)
}
fn arrow(&self, icon: &'static str, label: &Arc<str>, part: &str, to: Option<usize>, held: &ElementRef) -> Element {
let (before, after) = self.neighbours();
let rules = self.recipe.rules_for(CarouselPart::Arrow, ButtonPart::Root);
let turn = self.turn.clone();
let mut button = Button::new(label.as_ref())
.icon(icon)
.icon_only(true)
.variant(ButtonVariant::Outline)
.shape(ButtonShape::Pill)
.ref_element(held.clone())
.rules(&rules)
.disabled(self.carousel.disabled || to.is_none())
.on_click({
let turn = turn.clone();
move |_: MouseEvent| {
if let Some(to) = to {
turn(to);
}
}
});
if let Some(id) = self.id(part) {
button = button.id(id);
}
Row::new()
.on_key_down(move |event: KeyboardEvent| {
if !event.focus_within {
return;
}
let to = match event.key.as_str() {
"ArrowLeft" => before,
"ArrowRight" => after,
_ => return,
};
event.prevent_default();
event.stop_propagation();
if let Some(to) = to {
turn(to);
}
})
.child(button)
.into()
}
pub fn previous(&self) -> Option<Element> {
let (before, _) = self.neighbours();
self.carousel.arrows.then(|| {
self.arrow(
icons::ARROW_LEFT,
&self.carousel.words.previous,
"previous",
before,
&self.arrows[0],
)
})
}
pub fn next(&self) -> Option<Element> {
let (_, after) = self.neighbours();
self.carousel.arrows.then(|| {
self.arrow(
icons::ARROW_RIGHT,
&self.carousel.words.next,
"next",
after,
&self.arrows[1],
)
})
}
pub fn viewport(&self) -> Element {
let carousel = &self.carousel;
let count = carousel.slides.len();
let full = Dimension::Pct(100.0);
let mut list = Row::new().align_items(Alignment::Stretch);
for (at, slide) in carousel.slides.iter().enumerate() {
let mut room = Column::new()
.part(&self.part(CarouselPart::Slide))
.align_items(Alignment::Stretch)
.padding_right(carousel.gap)
.describe("a11y_role", "group")
.describe(
"a11y_roledescription",
super::current_locale().navigation.slide_role.clone(),
)
.describe("a11y_name", carousel.name_of(at + 1, count))
.child(slide.clone());
if self.step > 0.0 {
room = room.width(self.step);
} else {
room = room.width(full);
}
if let Some(id) = self.id(&format!("slide-{at}")) {
room = room.id(id);
}
let mut room: Element = room.into();
if !(self.index..self.index + self.shown).contains(&at) {
NodeUpdate::inert(&mut *room.node, true);
}
list = list.child(room);
}
let (scrolled, rest) = (self.scrolled.clone(), self.settle.clone());
let mut slides = ScrollHorizontal::new(list)
.with_scroll_state(self.scroll.clone())
.scrollbar(ScrollBarStyle::hidden())
.on_scroll(move |_: ScrollEvent| scrolled())
.on_scroll_end(move |_: ScrollEvent| rest());
if !carousel.disabled && self.places > 1 {
let Dragged { start, moved, end } = self.dragged.clone();
slides = slides
.on_drag_start(move |_: DragEvent| start())
.on_drag_move(move |event: DragEvent| moved(event.delta_x))
.on_drag_end(move |event: DragEvent| end(event.total_delta_x));
}
slides = match self.step > 0.0 {
true => slides.width(self.step * self.shown as f32),
false => slides.width(full),
};
let mut viewport = Row::new()
.part(&self.part(CarouselPart::Viewport))
.flex(1.0)
.min_width(0.0)
.clip()
.ref_element(self.viewport.clone())
.child(slides);
if let Some(id) = self.id("viewport") {
viewport = viewport.id(id);
}
let mut viewport: Element = viewport.into();
if carousel.disabled {
NodeUpdate::inert(&mut *viewport.node, true);
}
viewport
}
pub fn dots(&self) -> Option<Element> {
let carousel = &self.carousel;
if !carousel.dots || self.places < 2 {
return None;
}
let mut dots = Row::new()
.part(&self.part(CarouselPart::Dots))
.align_items(Alignment::Center)
.focus_group(FocusGroup::horizontal().one_stop(true))
.describe("a11y_role", "tablist")
.describe("a11y_name", carousel.words.label.clone());
for at in 0..self.places {
let current = at == self.index;
let recipe = if current { &self.current } else { &self.recipe };
let turn = self.turn.clone();
let mut dot = pressable(&recipe.part(CarouselPart::Dot), carousel.disabled)
.describe("a11y_role", "tab")
.describe("a11y_name", carousel.name_of(at + 1, carousel.slides.len()))
.describe("a11y_selected", if current { "true" } else { "false" })
.child({
let mark = Row::new().part(&recipe.part(CarouselPart::DotMark));
match self.id(&format!("dot-{at}-mark")) {
Some(id) => mark.id(id),
None => mark,
}
})
.on_click(move |_: MouseEvent| turn(at));
if let Some(id) = self.id(&format!("dot-{at}")) {
dot = dot.id(id);
}
dots = dots.child(dot);
}
Some(dots.into())
}
pub fn render(self) -> Element {
let carousel = &self.carousel;
let full = Dimension::Pct(100.0);
let width = carousel
.width
.and_then(|width| width.resolve(self.theme()))
.unwrap_or(full);
let track = Row::new()
.part(&self.part(CarouselPart::Track))
.width(full)
.align_items(Alignment::Center)
.with_children(self.previous())
.child(self.viewport())
.with_children(self.next());
let mut root = Column::new()
.part(&self.part(CarouselPart::Root))
.width(width)
.max_width(full)
.align_items(Alignment::Center)
.ref_element(self.root.clone())
.describe("a11y_role", "region")
.describe(
"a11y_roledescription",
super::current_locale().navigation.carousel_role.clone(),
)
.describe("a11y_name", carousel.words.label.clone())
.child(track)
.with_children(self.dots());
if let Some(id) = &carousel.id {
root = root.id(id.clone());
}
if let Some(key) = &carousel.key {
root = root.key(key.clone());
}
root.into()
}
}
impl crate::ui::Styled for Carousel {
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 Carousel {
const NAME: &'static str = "carousel";
type Renderer = CarouselRenderer;
fn parts() -> crate::ui::Declared {
CarouselPart::declared()
}
fn states() -> crate::ui::Declared {
CarouselState::declared()
}
fn recipe() -> Recipe {
use CarouselPart::*;
use PaletteColor::{Input, Primary};
Recipe::new()
.base(Root, |s| s.gap(12.0))
.base(Track, |s| s.gap(12.0))
.base(Dot, |s| {
s.padding_x(3.0)
.padding_y(3.0)
.radius(RadiusSize::Full)
.cursor(CursorIcon::Pointer)
})
.focus_visible(Dot, |s| s.focus_ring())
.base(DotMark, |s| {
fading(s.square(6.0).radius(RadiusSize::Full).background(Input))
})
.state(CarouselState::Current, DotMark, |s| s.background(Primary))
.state(CarouselState::Disabled, Root, |s| s.opacity(OpacityLevel::Disabled))
.state(CarouselState::Disabled, Dot, |s| s.cursor(CursorIcon::Default))
}
}