use std::rc::Rc;
use std::time::Instant;
use crabshell_reactive::untrack;
use crate::animation::{self, Spring};
use crate::geometry::{Point, Rect};
use crate::input::{DRAG_THRESHOLD, Pointer, ScrollSource, Wheel, WheelAxis, local};
use crate::scroll::PIXELS_PER_NOTCH;
use crate::tree::{Change, NodeId, NodeKind, ScrollNode, Tree};
const DECELERATION: f32 = 1500.0;
const MAX_SPEED: f32 = 2500.0;
const MIN_FLING: f32 = 50.0;
const SAMPLE_MS: u32 = 100;
const OVERSHOOT_LIMIT: f32 = 0.25;
const RESISTANCE: f32 = 0.5;
const SPRING_BACK: Spring = Spring::new(150.0, 1.0);
const REST: (f32, f32) = (0.5, 10.0);
const MAX_STEP: f32 = 0.25;
#[derive(Default)]
pub(crate) struct Motion {
samples: Vec<(u32, f32)>,
raw: f32,
generation: u64,
}
#[derive(Clone, Copy)]
enum Phase {
Fling { v: f32 },
Spring { x: f32, v: f32 },
}
pub(crate) struct Flick {
views: Vec<NodeId>,
at: Point,
last: Point,
view: Option<NodeId>,
may_drag: bool,
}
#[derive(Clone, Copy)]
pub(crate) struct BarDrag {
pub(crate) view: NodeId,
from: f32,
offset: f32,
handle: bool,
}
impl Pointer {
pub(crate) fn forget_views(&mut self, removed: &[NodeId]) {
if let Some(flick) = self.flick.as_mut() {
flick.views.retain(|id| !removed.contains(id));
if flick.view.is_some_and(|id| removed.contains(&id)) {
flick.view = None;
flick.may_drag = false;
}
}
if self.gesture.is_some_and(|id| removed.contains(&id)) {
self.gesture = None;
}
if self.bar.is_some_and(|bar| removed.contains(&bar.view)) {
self.bar = None;
}
}
}
impl ScrollNode {
pub(crate) fn current(&self) -> Option<f32> {
let now = untrack(|| self.signal.try_get())?;
Some(if now.is_nan() {
0.0
} else {
now.clamp(0.0, self.most)
})
}
fn limit(&self) -> f32 {
(self.length * OVERSHOOT_LIMIT).max(0.0)
}
fn rubber(&self, raw: f32) -> f32 {
let limit = self.limit();
if limit <= 0.0 || !raw.is_finite() {
return 0.0;
}
raw.signum() * limit * (1.0 - (-RESISTANCE * raw.abs() / limit).exp())
}
fn unrubber(&self, shown: f32) -> f32 {
let limit = self.limit();
if limit <= 0.0 || shown == 0.0 {
return 0.0;
}
let part = (shown.abs() / limit).min(0.999);
-shown.signum() * limit / RESISTANCE * (1.0 - part).ln()
}
fn halt(&mut self) {
self.set_moving(false);
self.motion.generation += 1;
self.motion.samples.clear();
self.motion.raw = self.unrubber(self.overshoot);
}
pub(crate) fn stop_overshoot(&mut self) -> Change {
self.set_moving(false);
self.motion.generation += 1;
self.motion.samples.clear();
self.motion.raw = 0.0;
if std::mem::replace(&mut self.overshoot, 0.0) != 0.0 {
Change::Place
} else {
Change::None
}
}
fn push(&mut self, delta: f32, time: u32) -> (Option<f32>, Change) {
let Some(now) = self.current() else {
return (None, Change::None);
};
self.set_moving(true);
let total = now + self.motion.raw + delta;
let offset = total.clamp(0.0, self.most);
self.motion.raw = if self.overshoots { total - offset } else { 0.0 };
let samples = &mut self.motion.samples;
samples.retain(|&(then, _)| time.wrapping_sub(then) <= SAMPLE_MS);
samples.push((time, delta));
let shown = self.rubber(self.motion.raw);
let change = if std::mem::replace(&mut self.overshoot, shown) != shown {
Change::Place
} else {
Change::None
};
((offset != now).then_some(offset), change)
}
fn set_moving(&self, moving: bool) {
if let Some(cell) = &self.moving {
cell.set(moving);
}
}
fn speed(&self, time: u32) -> f32 {
let recent: Vec<(u32, f32)> = self
.motion
.samples
.iter()
.copied()
.filter(|&(then, _)| time.wrapping_sub(then) <= SAMPLE_MS)
.collect();
let (Some(first), Some(last)) = (recent.first(), recent.last()) else {
return 0.0;
};
let span = last.0.wrapping_sub(first.0);
if span == 0 {
return 0.0;
}
let distance: f32 = recent[1..].iter().map(|&(_, delta)| delta).sum();
(distance * 1000.0 / span as f32).clamp(-MAX_SPEED, MAX_SPEED)
}
fn can_move(&self, delta: f32) -> bool {
self
.current()
.is_some_and(|now| (delta > 0.0 && now < self.most) || (delta < 0.0 && now > 0.0))
}
fn along(&self, at: Point) -> f32 {
if self.horizontal { at.x } else { at.y }
}
fn span(&self, rect: Rect) -> (f32, f32) {
if self.horizontal {
(rect.x, rect.width)
} else {
(rect.y, rect.height)
}
}
pub(crate) fn wheel_pixels(&self, wheel: Wheel) -> Option<f32> {
let notched = |axis: WheelAxis| {
(axis.notches != 0.0 && axis.notches.is_finite()).then_some(axis.notches * PIXELS_PER_NOTCH)
};
let smooth =
|axis: WheelAxis| (axis.pixels != 0.0 && axis.pixels.is_finite()).then_some(axis.pixels);
if self.horizontal {
notched(wheel.x)
.or_else(|| smooth(wheel.x))
.or_else(|| notched(wheel.y))
} else {
notched(wheel.y).or_else(|| smooth(wheel.y))
}
}
}
impl Tree {
pub(crate) fn scroll_views_at(&self, point: Point) -> Vec<NodeId> {
self.scroll_chain(self.root, point)
}
fn scroll_chain(&self, id: NodeId, point: Point) -> Vec<NodeId> {
let Some(node) = self.node(id) else {
return Vec::new();
};
let Some(point) = local(node, point) else {
return Vec::new();
};
if !node.inner_bounds.contains(point) {
return Vec::new();
}
let mut chain = self
.drawn_children(id)
.into_iter()
.rev()
.map(|child| self.scroll_chain(child, point))
.find(|chain| !chain.is_empty())
.unwrap_or_default();
if node.rect.is_some_and(|rect| rect.contains(point))
&& matches!(node.kind, NodeKind::Scroll(_))
{
chain.push(id);
}
chain
}
pub(crate) fn scroll_view(&mut self, wheel: Wheel, time: u32) {
let finger = wheel.source == ScrollSource::Finger;
if let Some((id, pixels)) = self.wheel_target(wheel, finger) {
if finger {
if self.pointer.gesture != Some(id) {
if let Some(last) = self.pointer.gesture.replace(id) {
self.release_view(last, None);
}
self.update_scroll(id, |scroll| {
scroll.halt();
Change::None
});
}
self.push_view(id, pixels, time);
} else {
let mut write = None;
self.update_scroll(id, |scroll| {
let change = scroll.stop_overshoot();
if let Some(now) = scroll.current() {
let offset = (now + pixels).clamp(0.0, scroll.most);
write = (offset != now).then_some((scroll.signal, offset));
}
change
});
if let Some((signal, offset)) = write {
signal.try_set(offset);
}
}
}
}
fn wheel_target(&self, wheel: Wheel, finger: bool) -> Option<(NodeId, f32)> {
let chain = self.scroll_views_at(self.pointer.position?);
let scroll = |id: NodeId| match self.node(id).map(|node| &node.kind) {
Some(NodeKind::Scroll(scroll)) => Some(&**scroll),
_ => None,
};
let past = self
.pointer
.gesture
.filter(|id| finger && chain.contains(id))
.filter(|&id| scroll(id).is_some_and(|scroll| scroll.motion.raw != 0.0));
if let Some(id) = past {
return Some((id, scroll(id)?.wheel_pixels(wheel)?));
}
let moves = chain.iter().find_map(|&id| {
let pixels = scroll(id)?.wheel_pixels(wheel)?;
scroll(id)?.can_move(pixels).then_some((id, pixels))
});
moves.or_else(|| {
chain.iter().filter(|_| finger).find_map(|&id| {
let scroll = scroll(id)?;
Some((
id,
scroll.wheel_pixels(wheel).filter(|_| scroll.overshoots)?,
))
})
})
}
fn push_view(&mut self, id: NodeId, delta: f32, time: u32) {
let mut write = None;
self.update_scroll(id, |scroll| {
let (offset, change) = scroll.push(delta, time);
write = offset.map(|offset| (scroll.signal, offset));
change
});
if let Some((signal, offset)) = write {
signal.try_set(offset);
}
}
pub(crate) fn release_view(&mut self, id: NodeId, time: Option<u32>) {
let Some(NodeKind::Scroll(scroll)) = self.node_mut(id).map(|node| &mut node.kind) else {
return;
};
let speed = time.map_or(0.0, |time| scroll.speed(time));
scroll.motion.samples.clear();
scroll.motion.raw = 0.0;
let phase = if scroll.overshoot != 0.0 {
Phase::Spring {
x: scroll.overshoot,
v: 0.0,
}
} else if scroll.kinetic && speed.abs() >= MIN_FLING {
Phase::Fling { v: speed }
} else {
scroll.set_moving(false);
return;
};
self.start_motion(id, phase);
}
fn start_motion(&mut self, id: NodeId, mut phase: Phase) {
let tree = self.this.clone();
let Some(node) = self.node_mut(id) else {
return;
};
let label: Rc<str> = format!("{}.kinetic", node.path).into();
let NodeKind::Scroll(scroll) = &mut node.kind else {
return;
};
let Some(mut written) = scroll.current() else {
return;
};
if let Some(shifts) = &scroll.shifts {
shifts.set(0.0);
}
scroll.motion.generation += 1;
let generation = scroll.motion.generation;
let mut previous: Option<Instant> = None;
animation::start(
label,
Box::new(move |now| {
let Some(tree) = tree.upgrade() else {
return false;
};
let Ok(mut tree) = tree.try_borrow_mut() else {
return true;
};
let seconds = previous.map_or(0.0, |previous| {
now
.saturating_duration_since(previous)
.as_secs_f32()
.min(MAX_STEP)
});
previous = Some(now);
tree.step_motion(id, generation, &mut phase, &mut written, seconds)
}),
);
}
fn step_motion(
&mut self,
id: NodeId,
generation: u64,
phase: &mut Phase,
written: &mut f32,
seconds: f32,
) -> bool {
let mut running = false;
let mut write = None;
self.update_scroll(id, |scroll| {
if scroll.motion.generation != generation {
return Change::None;
}
let Some(offset) = scroll.current() else {
return Change::None;
};
if let Some(shifts) = &scroll.shifts {
*written += shifts.take();
}
if offset != *written {
return scroll.stop_overshoot();
}
let mut to = offset;
let mut overshoot = scroll.overshoot;
match phase {
Phase::Fling { v } => {
let slowed = v.signum() * (v.abs() - DECELERATION * seconds).max(0.0);
let moved = offset + (*v + slowed) / 2.0 * seconds;
to = moved.clamp(0.0, scroll.most);
if moved != to && scroll.overshoots {
overshoot = (moved - to).clamp(-scroll.limit(), scroll.limit());
*phase = Phase::Spring {
x: overshoot,
v: slowed,
};
running = true;
} else {
*phase = Phase::Fling { v: slowed };
running = moved == to && slowed != 0.0;
}
}
Phase::Spring { x, v } => {
let (mut x64, mut v64) = (f64::from(*x), f64::from(*v));
SPRING_BACK.advance(&mut x64, &mut v64, 0.0, f64::from(seconds));
let limit = scroll.limit();
let clamped = (x64 as f32).clamp(-limit, limit);
let rest = clamped.abs() < REST.0 && (v64 as f32).abs() < REST.1;
*x = if rest { 0.0 } else { clamped };
*v = v64 as f32;
overshoot = *x;
running = !rest;
}
}
if to != offset {
*written = to;
write = Some((scroll.signal, to));
}
if !running {
scroll.set_moving(false);
}
if std::mem::replace(&mut scroll.overshoot, overshoot) != overshoot {
Change::Place
} else {
Change::None
}
});
if let Some((signal, offset)) = write {
signal.try_set(offset);
}
running
}
pub(crate) fn press_views(&mut self, at: Point, drags: bool) {
let mut views = self.scroll_views_at(at);
views.retain(|&id| self.press_reaches(id));
for &id in &views {
self.update_scroll(id, |scroll| {
scroll.halt();
Change::None
});
}
self.pointer.flick = (!views.is_empty()).then_some(Flick {
views,
at,
last: at,
view: None,
may_drag: !drags,
});
}
pub(crate) fn flick_motion(&mut self, at: Point, time: u32) -> bool {
let Some(flick) = self.pointer.flick.as_mut() else {
return false;
};
let last = std::mem::replace(&mut flick.last, at);
if let Some(id) = flick.view {
let delta = self.along_view(id, last) - self.along_view(id, at);
self.push_view(id, delta, time);
return true;
}
let (dx, dy) = (at.x - flick.at.x, at.y - flick.at.y);
if !flick.may_drag || dx.abs().max(dy.abs()) <= DRAG_THRESHOLD {
return false;
}
let (from, views) = (flick.at, flick.views.clone());
let sideways = dx.abs() > dy.abs();
let along: Vec<(NodeId, f32)> = views
.into_iter()
.filter(|&id| matches!(self.node(id).map(|node| &node.kind), Some(NodeKind::Scroll(scroll)) if scroll.horizontal == sideways))
.map(|id| (id, self.along_view(id, from) - self.along_view(id, at)))
.collect();
let can = |id: NodeId, test: &dyn Fn(&ScrollNode) -> bool| matches!(self.node(id).map(|node| &node.kind), Some(NodeKind::Scroll(scroll)) if test(scroll));
let picked = along
.iter()
.find(|&&(id, delta)| can(id, &|scroll| scroll.can_move(delta)))
.or_else(|| {
along
.iter()
.find(|&&(id, _)| can(id, &|scroll| scroll.overshoots))
})
.copied();
let Some((id, delta)) = picked else {
if let Some(flick) = self.pointer.flick.as_mut() {
flick.may_drag = false;
}
return false;
};
if let Some(flick) = self.pointer.flick.as_mut() {
flick.view = Some(id);
}
self.cancel_press();
self.push_view(id, delta, time);
true
}
fn along_view(&self, id: NodeId, at: Point) -> f32 {
match (
self.node(id).map(|node| &node.kind),
self.local_point(id, at),
) {
(Some(NodeKind::Scroll(scroll)), Some(point)) => scroll.along(point),
_ => 0.0,
}
}
pub(crate) fn flick_release(&mut self, time: Option<u32>) {
let Some(flick) = self.pointer.flick.take() else {
return;
};
for id in flick.views {
let time = time.filter(|_| flick.view == Some(id));
self.release_view(id, time);
}
}
pub(crate) fn press_bar(&mut self, at: Point) -> bool {
for id in self.scroll_views_at(at) {
if !self.press_reaches(id) {
continue;
}
let Some(point) = self.local_point(id, at) else {
continue;
};
let Some(NodeKind::Scroll(scroll)) = self.node(id).map(|node| &node.kind) else {
continue;
};
let (Some((track, handle)), Some(rect)) = (scroll.handle, self.node(id).and_then(|n| n.rect))
else {
continue;
};
if !track.contains(point) {
continue;
}
let Some(offset) = scroll.current() else {
return true;
};
let from = scroll.along(point);
let on_handle = handle.contains(point);
let (start, _) = scroll.span(handle);
let (_, page) = scroll.span(rect);
let to = if on_handle {
offset
} else if from < start {
offset - page
} else {
offset + page
};
let (to, signal) = (to.clamp(0.0, scroll.most), scroll.signal);
self.update_scroll(id, |scroll| {
scroll.halt();
Change::None
});
self.pointer.bar = Some(BarDrag {
view: id,
from,
offset,
handle: on_handle,
});
if to != offset {
signal.try_set(to);
}
return true;
}
false
}
fn press_reaches(&self, id: NodeId) -> bool {
self
.pointer
.hovered
.is_none_or(|hovered| self.path_to(hovered).contains(&id))
}
pub(crate) fn bar_motion(&mut self, at: Point) {
let Some(drag) = self.pointer.bar.filter(|bar| bar.handle) else {
return;
};
let Some(point) = self.local_point(drag.view, at) else {
return;
};
let Some(NodeKind::Scroll(scroll)) = self.node(drag.view).map(|node| &node.kind) else {
return;
};
let Some((track, handle)) = scroll.handle else {
return;
};
let room = scroll.span(track).1 - scroll.span(handle).1;
if room <= 0.0 {
return;
}
let to = (drag.offset + (scroll.along(point) - drag.from) * scroll.most / room)
.clamp(0.0, scroll.most);
if scroll.current() != Some(to) {
scroll.signal.try_set(to);
}
}
}