use super::{Tree, find_node_by_id, hit_test_tree, scrollbar_hit_at, trim_hits_to_scrollbar};
use crate::{
app::events::ScrollPhase,
core::NodeId,
layout::layout_kind::{ScrollDirection, ScrollState},
node::{node::Node, node_kind::NodeKind},
time::{Duration, Instant},
};
const RUBBER_BAND: f32 = 0.55;
const SPRING_FREQUENCY: f32 = 10.0;
const SPRING_REST: f32 = 0.5;
const SPRING_MIN: Duration = Duration::from_millis(100);
const TO_TOP: Duration = Duration::from_millis(350);
const PAGE_FREQUENCY: f32 = 14.0;
const PAGE_FLICK: f32 = 200.0;
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct TouchMomentum {
pub deceleration_rate: f32,
pub velocity_window: Duration,
pub min_speed: f32,
pub max_speed: f32,
pub stop_speed: f32,
}
impl Default for TouchMomentum {
fn default() -> Self {
Self {
deceleration_rate: 0.998,
velocity_window: Duration::from_millis(100),
min_speed: 50.0,
max_speed: 8000.0,
stop_speed: 15.0,
}
}
}
fn rubber(pull: f32, size: f32) -> f32 {
if size <= 0.0 {
return 0.0;
}
pull.signum() * (1.0 - 1.0 / (pull.abs() * RUBBER_BAND / size + 1.0)) * size
}
fn pull_of(shown: f32, size: f32) -> f32 {
let share = (shown.abs() / size.max(f32::EPSILON)).min(0.999);
shown.signum() * size / RUBBER_BAND * (1.0 / (1.0 - share) - 1.0)
}
struct Taker {
state: ScrollState,
axes: (bool, bool),
}
impl Taker {
fn offsets(&self) -> (f32, f32) {
(self.state.scroll_x(), self.state.scroll_y())
}
fn ends(&self) -> (f32, f32) {
let width = (self.state.content_width() - self.state.viewport_width()).max(0.0);
let height = (self.state.content_height() - self.state.viewport_height()).max(0.0);
(
if self.axes.0 { width } else { 0.0 },
if self.axes.1 { height } else { 0.0 },
)
}
fn viewport(&self) -> (f32, f32) {
(self.state.viewport_width(), self.state.viewport_height())
}
}
fn at_end(offset: f32, end: f32, change: f32) -> bool {
end > 0.0 && ((change > 0.0 && offset >= end) || (change < 0.0 && offset <= 0.0))
}
struct Spring {
from: (f32, f32),
velocity: (f32, f32),
started: Instant,
released: bool,
}
impl Spring {
fn at(&self, elapsed: f32) -> (f32, f32) {
self.at_frequency(SPRING_FREQUENCY, elapsed)
}
fn at_frequency(&self, frequency: f32, elapsed: f32) -> (f32, f32) {
let decay = (-frequency * elapsed).exp();
let axis = |from: f32, velocity: f32| (from + (velocity + frequency * from) * elapsed) * decay;
(axis(self.from.0, self.velocity.0), axis(self.from.1, self.velocity.1))
}
}
struct PageMove {
to: (f32, f32),
spring: Spring,
}
fn page_target(offset: f32, began: f32, size: f32, end: f32, speed: f32) -> f32 {
if size <= 0.0 || end <= 0.0 {
return offset.clamp(0.0, end.max(0.0));
}
let from = (began / size).round();
let at = offset / size;
let page = if speed > PAGE_FLICK {
at.ceil()
} else if speed < -PAGE_FLICK {
at.floor()
} else {
at.round()
};
(page.clamp(from - 1.0, from + 1.0) * size).clamp(0.0, end)
}
#[derive(Default)]
pub(super) struct TouchScroll {
taker: Option<Taker>,
around: Vec<NodeId>,
pull: (f32, f32),
spring: Option<Spring>,
to_top: Option<ToTop>,
began: (f32, f32),
page: Option<PageMove>,
caught_page: Option<(f32, f32)>,
}
struct ToTop {
state: ScrollState,
around: Vec<NodeId>,
from: f32,
started: Instant,
}
impl Tree {
pub fn set_double_click_distance(&mut self, distance: f32) {
self.double_click_distance = Some(distance);
}
pub fn set_double_click_interval(&mut self, interval: Duration) {
self.double_click_interval = Some(interval);
}
pub fn set_touch_momentum(&mut self, momentum: TouchMomentum) {
self.touch_momentum = momentum;
}
pub fn touch_momentum(&self) -> TouchMomentum {
self.touch_momentum
}
pub fn touch_scrolls_at(&mut self, x: f32, y: f32) -> bool {
let scale = self.scale_factor();
let (lx, ly) = (x / scale, y / scale);
self.rebuild_if_dirty();
let (Some(root), Some(layout)) = (&self.root, &self.last_layout) else {
return false;
};
let mut hits = super::scroll_hits(root, layout, lx, ly, &self.layout_engine.radii());
trim_hits_to_scrollbar(&mut hits, lx, ly);
let on_scrollbar = hits.first().is_some_and(|(node, _)| {
scrollbar_hit_at(node, lx, ly).is_some()
&& !node
.scrollbar_style(crate::layout::scrollbar::ScrollBarStyle::default())
.visible
.fades()
});
let on_slider = hits
.iter()
.any(|(node, _)| matches!(node.node_kind(), NodeKind::Slider { .. }) || node.events.finger_drags);
if on_scrollbar || on_slider {
return false;
}
hits.iter().any(|(node, _)| {
node.scroll_container().is_some_and(|(state, _)| {
state.content_height() > state.viewport_height() || state.content_width() > state.viewport_width()
})
})
}
pub fn touch_keyboard_follows_at(&mut self, x: f32, y: f32) -> bool {
if !self.focused_text_input() {
return false;
}
let scale = self.scale_factor();
let (lx, ly) = (x / scale, y / scale);
self.rebuild_if_dirty();
let (Some(root), Some(layout)) = (&self.root, &self.last_layout) else {
return false;
};
let mut hits = Vec::new();
hit_test_tree(root, layout, 0.0, 0.0, lx, ly, &self.layout_engine.radii(), &mut hits);
hits.iter().any(|(node, _)| {
node.scroll_container().is_some_and(|(state, _)| {
state.keyboard_dismissal() == crate::layout::layout_kind::KeyboardDismissal::Interactive
})
})
}
pub fn keyboard_was_put_away(&mut self) {
if self.focused_text_input() {
self.blur_focus();
}
}
pub fn touch_scroll_begin(&mut self, x: f32, y: f32, delta_x: f32, delta_y: f32) {
let scale = self.scale_factor();
let (lx, ly) = (x / scale, y / scale);
self.rebuild_if_dirty();
self.touch_scroll_targets.clear();
let (Some(root), Some(layout)) = (&self.root, &self.last_layout) else {
return;
};
let hits = super::scroll_hits(root, layout, lx, ly, &self.layout_engine.radii());
let vertical = delta_y.abs() >= delta_x.abs();
let forward = if vertical { delta_y < 0.0 } else { delta_x < 0.0 };
let along_axis = |node: &Node| {
let (state, direction) = node.scroll_container()?;
let along = match direction {
ScrollDirection::Both => true,
ScrollDirection::Vertical => vertical,
ScrollDirection::Horizontal => !vertical,
};
along.then_some(state)
};
let has_room = |node: &Node| {
along_axis(node).is_some_and(|state| {
let (offset, end) = if vertical {
(state.scroll_y(), state.content_height() - state.viewport_height())
} else {
(state.scroll_x(), state.content_width() - state.viewport_width())
};
if forward { offset < end } else { offset > 0.0 }
})
};
let taker = hits
.iter()
.position(|(node, _)| has_room(node))
.or_else(|| hits.iter().position(|(node, _)| along_axis(node).is_some()));
let heard = taker.map_or(hits.len(), |taker| taker + 1);
self
.touch_scroll_targets
.extend(hits[..heard].iter().map(|(node, _)| node.node_id()));
let around = taker.map_or(Vec::new(), |taker| {
hits[taker..].iter().map(|(node, _)| node.node_id()).collect()
});
let taker = taker.and_then(|taker| {
let node = hits[taker].0;
let (state, direction) = node.scroll_container()?;
Some(Taker {
state,
axes: (
!matches!(direction, ScrollDirection::Vertical),
!matches!(direction, ScrollDirection::Horizontal),
),
})
});
drop(hits);
if taker.as_ref().is_some_and(|taker| taker.state.dismisses_keyboard()) && self.focused_text_input() {
self.blur_focus();
}
let previous = std::mem::take(&mut self.touch_scroll);
let caught = previous
.taker
.as_ref()
.zip(taker.as_ref())
.is_some_and(|(previous, taker)| previous.state.ptr_eq(&taker.state));
let pull = match &taker {
Some(taker) if caught => {
let (shown, viewport) = (taker.state.overscroll(), taker.viewport());
(pull_of(shown.0, viewport.0), pull_of(shown.1, viewport.1))
}
_ => (0.0, 0.0),
};
if !caught && let Some(previous) = &previous.taker {
previous.state.set_overscroll(0.0, 0.0);
}
let began = match (&taker, previous.caught_page) {
(Some(_), Some(page)) if caught => page,
(Some(taker), _) => taker.offsets(),
(None, _) => (0.0, 0.0),
};
self.touch_scroll = TouchScroll {
taker,
around,
pull,
spring: None,
to_top: None,
began,
page: None,
caught_page: None,
};
self.mark_touch_scroll_moved();
}
pub fn touch_scroll_pages(&self) -> bool {
self
.touch_scroll
.taker
.as_ref()
.is_some_and(|taker| taker.state.paging())
}
pub fn touch_scroll_page(&mut self, velocity_x: f32, velocity_y: f32, now: Instant) {
let scale = self.scale_factor();
let Some(taker) = &self.touch_scroll.taker else {
return;
};
if !taker.state.paging() || self.touch_scroll.spring.is_some() {
return;
}
let (offsets, ends, viewport) = (taker.offsets(), taker.ends(), taker.viewport());
let speed = (-velocity_x / scale, -velocity_y / scale);
let began = self.touch_scroll.began;
let to = (
page_target(offsets.0, began.0, viewport.0, ends.0, speed.0),
page_target(offsets.1, began.1, viewport.1, ends.1, speed.1),
);
if to == offsets {
return;
}
self.touch_scroll.page = Some(PageMove {
to,
spring: Spring {
from: (offsets.0 - to.0, offsets.1 - to.1),
velocity: (
if to.0 == offsets.0 { 0.0 } else { speed.0 },
if to.1 == offsets.1 { 0.0 } else { speed.1 },
),
started: now,
released: false,
},
});
self.needs_redraw = true;
}
pub fn touch_scroll(
&mut self,
x: f32,
y: f32,
delta_x: f32,
delta_y: f32,
phase: ScrollPhase,
momentum: bool,
) -> bool {
let scale = self.scale_factor();
let mut change = (-delta_x / scale, -delta_y / scale);
let pulled = self.touch_scroll.pull;
if !momentum {
let release = |pull: &mut f32, change: &mut f32| {
if *pull != 0.0 && pull.signum() != change.signum() {
let given = change.abs().min(pull.abs());
*pull -= pull.signum() * given;
*change -= change.signum() * given;
}
};
release(&mut self.touch_scroll.pull.0, &mut change.0);
release(&mut self.touch_scroll.pull.1, &mut change.1);
}
let before = self.touch_scroll.taker.as_ref().map(Taker::offsets);
self.touch_scroll_latched = true;
self.scroll(x, y, -change.0, -change.1, phase);
self.touch_scroll_latched = false;
let after = self.touch_scroll.taker.as_ref().map(Taker::offsets);
let springing = self.touch_scroll.spring.is_some();
if !momentum
&& !springing
&& let (Some(taker), Some(before), Some(after)) = (&self.touch_scroll.taker, before, after)
{
let ends = taker.ends();
let left = (change.0 - (after.0 - before.0), change.1 - (after.1 - before.1));
let mut pull = self.touch_scroll.pull;
if at_end(after.0, ends.0, left.0) {
pull.0 += left.0;
}
if at_end(after.1, ends.1, left.1) {
pull.1 += left.1;
}
let viewport = taker.viewport();
taker
.state
.set_overscroll(rubber(pull.0, viewport.0), rubber(pull.1, viewport.1));
self.touch_scroll.pull = pull;
if matches!(phase, ScrollPhase::End) && pull != (0.0, 0.0) {
self.touch_scroll.spring = Some(Spring {
from: taker.state.overscroll(),
velocity: (0.0, 0.0),
started: Instant::now(),
released: true,
});
self.touch_scroll.pull = (0.0, 0.0);
}
}
let moved = before != after || pulled != self.touch_scroll.pull;
if moved {
self.mark_touch_scroll_moved();
}
moved
}
pub fn touch_scroll_catch(&mut self) -> bool {
if self.touch_scroll.to_top.take().is_some() {
return true;
}
let Some(taker) = &self.touch_scroll.taker else {
return false;
};
if let Some(page) = self.touch_scroll.page.take() {
self.touch_scroll.began = page.to;
self.touch_scroll.caught_page = Some(page.to);
return true;
}
if self.touch_scroll.spring.take().is_none() {
return false;
}
let (shown, viewport) = (taker.state.overscroll(), taker.viewport());
self.touch_scroll.pull = (pull_of(shown.0, viewport.0), pull_of(shown.1, viewport.1));
true
}
pub fn touch_scroll_settle(&mut self) {
let Some(taker) = &self.touch_scroll.taker else {
return;
};
let shown = taker.state.overscroll();
self.touch_scroll.pull = (0.0, 0.0);
if shown != (0.0, 0.0) {
self.touch_scroll.spring = Some(Spring {
from: shown,
velocity: (0.0, 0.0),
started: Instant::now(),
released: true,
});
} else {
self.touch_scroll_page(0.0, 0.0, Instant::now());
}
}
pub fn touch_scroll_bounce(&mut self, velocity_x: f32, velocity_y: f32, now: Instant) {
let scale = self.scale_factor();
let Some(taker) = &self.touch_scroll.taker else {
return;
};
let released = match &self.touch_scroll.spring {
Some(spring) if spring.released => Some(spring.at(now.saturating_duration_since(spring.started).as_secs_f32())),
Some(_) => return,
None => None,
};
let (offsets, ends) = (taker.offsets(), taker.ends());
let speed = |velocity: f32, offset: f32, end: f32| {
let speed = -velocity / scale;
if at_end(offset, end, speed) { speed } else { 0.0 }
};
let velocity = (
speed(velocity_x, offsets.0, ends.0),
speed(velocity_y, offsets.1, ends.1),
);
let from = released.unwrap_or((0.0, 0.0));
let viewport = taker.viewport();
let follows = |shown: f32, size: f32| RUBBER_BAND * (1.0 - (shown.abs() / size.max(f32::EPSILON)).min(1.0)).powi(2);
let velocity = if released.is_some() {
(
velocity.0 * follows(from.0, viewport.0),
velocity.1 * follows(from.1, viewport.1),
)
} else {
velocity
};
if velocity != (0.0, 0.0) {
self.touch_scroll.spring = Some(Spring {
from,
velocity,
started: now,
released: false,
});
} else if let Some(spring) = &mut self.touch_scroll.spring {
spring.released = false;
}
}
pub fn touch_scroll_to_top(&mut self, now: Instant) -> bool {
self.rebuild_if_dirty();
let size = self.window.info().logical_size();
let (Some(root), Some(layout)) = (&self.root, &self.last_layout) else {
return false;
};
let mut hits = Vec::new();
hit_test_tree(
root,
layout,
0.0,
0.0,
size.width / 2.0,
size.height / 2.0,
&self.layout_engine.radii(),
&mut hits,
);
let page = hits.iter().rposition(|(node, _)| {
node.scroll_container().is_some_and(|(state, direction)| {
!matches!(direction, ScrollDirection::Horizontal) && state.scroll_y() > 0.0 && state.scrolls_to_top()
})
});
let Some(page) = page else {
return false;
};
let Some((state, _)) = hits[page].0.scroll_container() else {
return false;
};
let around = hits[page..].iter().map(|(node, _)| node.node_id()).collect();
drop(hits);
if let Some(taker) = &self.touch_scroll.taker {
taker.state.set_overscroll(0.0, 0.0);
}
self.touch_scroll.spring = None;
self.touch_scroll.page = None;
self.touch_scroll.pull = (0.0, 0.0);
self.touch_scroll.to_top = Some(ToTop {
from: state.scroll_y(),
state,
around,
started: now,
});
self.needs_redraw = true;
true
}
pub fn touch_tick(&mut self, now: Instant) -> bool {
let to_top = self.touch_to_top_tick(now) | self.touch_tap_highlight_tick(now) | self.touch_page_tick(now);
let (Some(taker), Some(spring)) = (&self.touch_scroll.taker, &self.touch_scroll.spring) else {
return to_top;
};
let elapsed = now.saturating_duration_since(spring.started);
let shown = spring.at(elapsed.as_secs_f32());
let rests = elapsed >= SPRING_MIN && shown.0.abs() < SPRING_REST && shown.1.abs() < SPRING_REST;
if rests {
taker.state.set_overscroll(0.0, 0.0);
self.touch_scroll.spring = None;
} else {
taker.state.set_overscroll(shown.0, shown.1);
}
self.mark_touch_scroll_moved();
!rests || to_top
}
fn touch_to_top_tick(&mut self, now: Instant) -> bool {
let Some(to_top) = &self.touch_scroll.to_top else {
return false;
};
let progress = now.saturating_duration_since(to_top.started).as_secs_f32() / TO_TOP.as_secs_f32();
let done = progress >= 1.0;
let left = (1.0 - progress.min(1.0)).powi(3);
to_top.state.set_scroll(to_top.state.scroll_x(), to_top.from * left);
if let Some(root) = &self.root {
mark_moved(root, &to_top.around);
}
self.needs_redraw = true;
if done {
self.touch_scroll.to_top = None;
}
!done
}
fn touch_page_tick(&mut self, now: Instant) -> bool {
let (Some(taker), Some(page)) = (&self.touch_scroll.taker, &self.touch_scroll.page) else {
return false;
};
let elapsed = now.saturating_duration_since(page.spring.started);
let left = page.spring.at_frequency(PAGE_FREQUENCY, elapsed.as_secs_f32());
let rests = elapsed >= SPRING_MIN && left.0.abs() < SPRING_REST && left.1.abs() < SPRING_REST;
if rests {
taker.state.set_scroll(page.to.0, page.to.1);
self.touch_scroll.page = None;
} else {
let within = |from: f32, left: f32| if from * left < 0.0 { 0.0 } else { left };
taker.state.set_scroll(
page.to.0 + within(page.spring.from.0, left.0),
page.to.1 + within(page.spring.from.1, left.1),
);
}
self.mark_touch_scroll_moved();
!rests
}
pub fn touch_animating(&self) -> bool {
self.touch_scroll.spring.is_some()
|| self.touch_scroll.to_top.is_some()
|| self.touch_scroll.page.is_some()
|| self.touch_tap_highlight_showing()
}
fn mark_touch_scroll_moved(&mut self) {
if let Some(root) = &self.root {
mark_moved(root, &self.touch_scroll.around);
}
self.needs_redraw = true;
}
}
fn mark_moved(root: &Node, around: &[NodeId]) {
for (index, target) in around.iter().enumerate() {
let Some(node) = find_node_by_id(root, *target) else {
continue;
};
if index == 0 {
node.layout_cache.mark_local_dirty();
}
node.layout_cache.mark_descendant_dirty();
}
}