use std::sync::{
Arc,
atomic::{AtomicBool, Ordering},
};
use parking_lot::Mutex;
use crate::{
app::{
component::Component,
ctx::Ctx,
events::{KeyboardEvent, ScrollEvent, ScrollSource},
},
components::{Column, Row, ScrollHorizontal, ScrollVertical},
core::{ElementRef, Signal, Visibility, VisibilityObserver, VisibilityOptions},
layout::{layout_kind::ScrollState, scrollbar::ScrollBarStyle},
node::{Element, NodeUpdate, dimension::Dimension},
time::{Duration, Instant},
};
type Page = Arc<dyn Fn(&mut Ctx, usize) -> Element + Send + Sync>;
type Told = Arc<dyn Fn(usize) + Send + Sync>;
const ONE_SWIPE: Duration = Duration::from_millis(140);
const TURNS_AGAIN_AFTER: Duration = Duration::from_millis(650);
const A_NOTCH: f32 = 30.0;
#[derive(Clone)]
pub struct Pager {
count: usize,
page: Page,
index: Option<Signal<usize>>,
told: Vec<Told>,
horizontal: bool,
beside: usize,
keys: bool,
width: Dimension,
height: Dimension,
id: Option<Arc<str>>,
key: Option<Arc<str>>,
}
impl Pager {
pub fn new<E: Into<Element>>(count: usize, page: impl Fn(&mut Ctx, usize) -> E + Send + Sync + 'static) -> Self {
Self {
count,
page: Arc::new(move |ctx, index| page(ctx, index).into()),
index: None,
told: Vec::new(),
horizontal: false,
beside: 1,
keys: true,
width: Dimension::Pct(100.0),
height: Dimension::Pct(100.0),
id: None,
key: None,
}
}
pub fn index(mut self, index: Signal<usize>) -> Self {
self.index = Some(index);
self
}
pub fn on_index_change(mut self, handler: impl Fn(usize) + Send + Sync + 'static) -> Self {
self.told.push(Arc::new(handler));
self
}
pub fn vertical(mut self) -> Self {
self.horizontal = false;
self
}
pub fn horizontal(mut self) -> Self {
self.horizontal = true;
self
}
pub fn beside(mut self, pages: usize) -> Self {
self.beside = pages.max(1);
self
}
pub fn keys(mut self, keys: bool) -> Self {
self.keys = keys;
self
}
pub fn width(mut self, width: impl Into<Dimension>) -> Self {
self.width = width.into();
self
}
pub fn height(mut self, height: impl Into<Dimension>) -> Self {
self.height = height.into();
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 = PagerProps(self);
match key {
Some(key) => ctx.mount_keyed::<PagerHost>(&key, props),
None => ctx.mount::<PagerHost>(props),
}
}
}
impl From<Pager> for Element {
fn from(pager: Pager) -> Self {
let key = pager.key.clone();
let props = PagerProps(pager);
match key {
Some(key) => Element::component_keyed::<PagerHost>(key, props),
None => Element::component::<PagerHost>(props),
}
}
}
#[derive(Clone)]
struct PagerProps(Pager);
impl PartialEq for PagerProps {
fn eq(&self, _: &Self) -> bool {
false
}
}
impl crate::app::component::DevtoolsInspectable for PagerProps {}
#[derive(Default)]
struct Wheel {
heard: Option<Instant>,
turned: Option<Instant>,
}
impl Wheel {
fn turns(&mut self, delta: f32, now: Instant) -> bool {
let new = self.heard.is_none_or(|heard| now.duration_since(heard) > ONE_SWIPE);
let again = delta.abs() >= A_NOTCH
&& self
.turned
.is_none_or(|turned| now.duration_since(turned) > TURNS_AGAIN_AFTER);
self.heard = Some(now);
if new || again {
self.turned = Some(now);
}
new || again
}
}
struct PagerHost {
index: Signal<usize>,
scroll: ScrollState,
root: ElementRef,
wide: Signal<f32>,
high: Signal<f32>,
near: Signal<usize>,
placed: Arc<Mutex<Option<(usize, f32)>>>,
asked: Arc<Mutex<Option<usize>>>,
again: Signal<u64>,
wheel: Arc<Mutex<Wheel>>,
shows: Arc<AtomicBool>,
_watching: Arc<VisibilityObserver>,
}
impl Component for PagerHost {
type Props = PagerProps;
fn create(ctx: &mut Ctx) -> Self {
let scroll = ScrollState::new();
scroll.set_paging(true);
let root = ElementRef::new();
let shows = Arc::new(AtomicBool::new(false));
let watching = root.observe_visibility(VisibilityOptions::new().thresholds([0.5]), {
let shows = shows.clone();
move |seen: Visibility| shows.store(seen.ratio >= 0.5, Ordering::Relaxed)
});
Self {
index: ctx.signal(0),
scroll,
root,
wide: ctx.signal(0.0),
high: ctx.signal(0.0),
near: ctx.signal(0),
placed: Arc::default(),
asked: Arc::default(),
again: ctx.signal(0),
wheel: Arc::default(),
shows,
_watching: Arc::new(watching),
}
}
fn render(&self, ctx: &mut Ctx) -> impl Into<Element> {
let pager = ctx.props::<PagerProps>().0.clone();
let horizontal = pager.horizontal;
let count = pager.count;
let last = count.saturating_sub(1);
let index_signal = pager.index.clone().unwrap_or_else(|| self.index.clone());
let index = index_signal.get().min(last);
let _ = self.again.get();
let (wide, high) = (self.wide.get(), self.high.get());
let length = if horizontal { wide } else { high };
let laid = length > 0.0;
let near = if self.placed.lock().is_some() {
self.near.get().min(last)
} else {
let _ = self.near.get();
index
};
let along = move |page: (usize, usize)| if horizontal { page.0 } else { page.1 };
let asked = self.asked.lock().take();
let mut aim = index;
if laid && count > 0 {
let offset = |page: usize| {
let to = page as f32 * length;
if horizontal { (to, 0.0) } else { (0.0, to) }
};
let mut placed = self.placed.lock();
match *placed {
Some((seen, was)) if (was - length).abs() < 0.25 => {
let going = along(self.scroll.target_page()).min(last);
aim = going;
let to = if seen != index { Some(index) } else { asked };
if let Some(to) = to.map(|to| to.min(last)).filter(|to| *to != going) {
let (x, y) = offset(to);
if to.abs_diff(going) <= pager.beside {
ctx.scroll_state_to(&self.scroll, x, y);
} else {
self.scroll.set_scroll_pending(x, y);
}
aim = to;
}
}
_ => {
let (x, y) = offset(index);
self.scroll.set_scroll_pending(x, y);
if self.near.get_untracked() != index {
self.near.set(index);
}
}
}
*placed = Some((index, length));
}
let tell = {
let (signal, told) = (index_signal.clone(), pager.told.clone());
move |to: usize| {
if signal.get_untracked() != to {
signal.set(to);
told.iter().for_each(|tell| tell(to));
}
}
};
let ask = {
let (asked, again) = (self.asked.clone(), self.again.clone());
move |to: usize| {
*asked.lock() = Some(to);
again.set(again.get_untracked().wrapping_add(1));
}
};
let mut built: Vec<usize> = Vec::new();
if count > 0 {
let centers = if laid { vec![index, near, aim] } else { vec![index] };
let beside = if laid { pager.beside } else { 0 };
for center in centers {
for page in center.saturating_sub(beside)..=(center + beside).min(last) {
if !built.contains(&page) {
built.push(page);
}
}
}
built.sort_unstable();
}
let full = Dimension::Pct(100.0);
let gap = |pages: usize| {
let long = pages as f32 * length;
if horizontal {
Column::new().width(long).height(high).flex_shrink(0.0)
} else {
Column::new().width(wide).height(long).flex_shrink(0.0)
}
};
let mut slots: Vec<Element> = Vec::new();
let mut next = 0;
for page in built {
if laid && page > next {
slots.push(gap(page - next).into());
}
let made = ctx.mount_keyed::<PageHost>(
&format!("page-{page}"),
PageProps {
index: page,
page: pager.page.clone(),
},
);
let mut slot = Column::new()
.key(format!("page-{page}"))
.flex_shrink(0.0)
.clip()
.child(made);
slot = if laid {
slot.width(wide).height(high)
} else {
slot.width(full).height(full)
};
if let Some(id) = &pager.id {
slot = slot.id(format!("{id}-page-{page}"));
}
let mut slot: Element = slot.into();
if page != index {
NodeUpdate::inert(&mut *slot.node, true);
}
slots.push(slot);
next = page + 1;
}
if laid && next < count {
slots.push(gap(count - next).into());
}
let scrolled = {
let (scroll, near, wheel, ask) = (self.scroll.clone(), self.near.clone(), self.wheel.clone(), ask.clone());
move |event: ScrollEvent| {
let turned = if horizontal { event.delta_x } else { event.delta_y };
if (event.delta_x, event.delta_y) == (0.0, 0.0) {
if matches!(
event.source,
ScrollSource::Finger | ScrollSource::Momentum | ScrollSource::Snap
) {
let page = along(scroll.page()).min(last);
if near.get_untracked() != page {
near.set(page);
}
}
return;
}
if event.source != ScrollSource::Wheel {
return;
}
event.prevent_default();
if turned == 0.0 || !wheel.lock().turns(turned, Instant::now()) {
return;
}
let going = along(scroll.target_page());
let to = if turned < 0.0 {
going + 1
} else {
going.saturating_sub(1)
};
if to <= last && to != going {
ask(to);
}
}
};
let paged = {
let near = self.near.clone();
move |page: usize| {
let page = page.min(last);
if near.get_untracked() != page {
near.set(page);
}
tell(page);
}
};
let list: Element = if horizontal {
Row::new().with_children(slots).into()
} else {
Column::new().with_children(slots).into()
};
let pages_id = pager.id.as_ref().map(|id| format!("{id}-pages"));
macro_rules! pages {
($list:expr) => {{
let mut pages = $list
.with_scroll_state(self.scroll.clone())
.scrollbar(ScrollBarStyle::hidden())
.on_scroll(scrolled)
.on_page_change(paged)
.width(full)
.height(full);
if let Some(id) = pages_id {
pages = pages.id(id);
}
Element::from(pages)
}};
}
let pages = if horizontal {
pages!(ScrollHorizontal::new(list))
} else {
pages!(ScrollVertical::new(list))
};
let mut root = Column::new()
.width(pager.width)
.height(pager.height)
.min_width(0.0)
.min_height(0.0)
.clip()
.ref_element(self.root.clone())
.child(pages);
if pager.keys && count > 1 {
let (scroll, shows) = (self.scroll.clone(), self.shows.clone());
root = root.on_key_down(move |event: KeyboardEvent| {
if event.text_input_focused || event.composing || event.ctrl || event.alt || event.meta {
return;
}
if !(event.focus_within || shows.load(Ordering::Relaxed)) {
return;
}
let going = along(scroll.target_page());
let to = match (event.key.as_str(), horizontal) {
("ArrowDown" | "PageDown", false) | ("ArrowRight", true) => going + 1,
("ArrowUp" | "PageUp", false) | ("ArrowLeft", true) => match going.checked_sub(1) {
Some(to) => to,
None => return,
},
("Home", false) => 0,
("End", false) => last,
_ => return,
};
if to > last || to == going {
return;
}
event.prevent_default();
event.stop_propagation();
ask(to);
});
}
if let Some(id) = &pager.id {
root = root.id(id.clone());
}
root
}
fn after_layout(&self) {
if !self.root.is_attached() {
return;
}
let (wide, high) = (self.root.width(), self.root.height());
if (self.wide.get_untracked() - wide).abs() > 0.25 {
self.wide.set(wide);
}
if (self.high.get_untracked() - high).abs() > 0.25 {
self.high.set(high);
}
}
}
struct PageProps {
index: usize,
page: Page,
}
impl PartialEq for PageProps {
fn eq(&self, _: &Self) -> bool {
false
}
}
impl crate::app::component::DevtoolsInspectable for PageProps {}
struct PageHost;
impl Component for PageHost {
type Props = PageProps;
fn create(_: &mut Ctx) -> Self {
Self
}
fn render(&self, ctx: &mut Ctx) -> impl Into<Element> {
let (index, page) = {
let props = ctx.props::<PageProps>();
(props.index, props.page.clone())
};
page(ctx, index)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_swipe_of_a_touchpad_turns_one_page_and_a_wheel_that_goes_on_turns_again() {
let start = Instant::now();
let at = |millis: u64| start + Duration::from_millis(millis);
let mut wheel = Wheel::default();
assert!(wheel.turns(-4.0, at(0)));
for step in 1..60 {
assert!(!wheel.turns(-12.0, at(step * 16)), "step {step} of one swipe");
}
assert!(wheel.turns(-4.0, at(60 * 16 + 300)));
let mut wheel = Wheel::default();
assert!(wheel.turns(-120.0, at(0)));
for millis in (100..=600).step_by(100) {
assert!(!wheel.turns(-120.0, at(millis)), "the notch at {millis} ms");
}
assert!(wheel.turns(-120.0, at(700)));
}
}