use super::{
MouseModifiers, ScrollInput, Tree, find_node_by_id, find_scroll_node_id_by_state, hit_test_tree,
mark_scroll_layout_dirty, scrollbar_hit_at, trim_hits_to_scrollbar,
};
use crate::{
app::events::{ScrollPhase, ScrollSource},
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;
const PAGE_ARRIVED: f32 = 0.02;
#[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,
}
impl PageMove {
fn from_rest(offset: (f32, f32), to: (f32, f32), now: Instant) -> Self {
Self {
to,
spring: Spring {
from: (offset.0 - to.0, offset.1 - to.1),
velocity: (0.0, 0.0),
started: now,
released: false,
},
}
}
fn at(&self, now: Instant) -> ((f32, f32), bool) {
let elapsed = now.saturating_duration_since(self.spring.started);
let left = self.spring.at_frequency(PAGE_FREQUENCY, elapsed.as_secs_f32());
if elapsed >= SPRING_MIN && left.0.abs() < SPRING_REST && left.1.abs() < SPRING_REST {
return (self.to, true);
}
let within = |from: f32, left: f32| if from * left < 0.0 { 0.0 } else { left };
let at = (
self.to.0 + within(self.spring.from.0, left.0),
self.to.1 + within(self.spring.from.1, left.1),
);
(at, false)
}
}
impl PageMove {
fn arrived(&self, offset: (f32, f32), state: &ScrollState) -> bool {
let near = |at: f32, to: f32, page: f32| (at - to).abs() <= (page * PAGE_ARRIVED).max(SPRING_REST);
near(offset.0, self.to.0, state.viewport_width()) && near(offset.1, self.to.1, state.viewport_height())
}
}
struct Aside {
state: ScrollState,
node: Option<NodeId>,
page: PageMove,
}
impl Aside {
fn to(state: ScrollState, node: Option<NodeId>, to: (f32, f32), now: Instant) -> Self {
state.set_held(true);
state.set_page_target(Some(to));
let page = PageMove::from_rest((state.scroll_x(), state.scroll_y()), to, now);
Self { state, node, page }
}
}
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)>,
moving: bool,
caught: bool,
source: ScrollSource,
at: (f32, f32),
vertical: bool,
moved: Vec<(NodeId, ScrollState)>,
asides: Vec<Aside>,
}
struct ToTop {
state: ScrollState,
around: Vec<NodeId>,
from: f32,
started: Instant,
}
impl TouchScroll {
fn busy(&self) -> bool {
self.moving || self.caught || self.page.is_some() || self.spring.is_some()
}
}
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();
let heard_before = std::mem::take(&mut self.touch_scroll_targets);
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 now = self.press_now();
let mut previous = std::mem::take(&mut self.touch_scroll);
let mut asides = std::mem::take(&mut previous.asides);
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(taker) = &previous.taker {
taker.state.set_overscroll(0.0, 0.0);
let going = previous.caught_page.or(previous.page.as_ref().map(|page| page.to));
match going {
Some(page) => asides.push(Aside::to(
taker.state.clone(),
previous.around.first().copied(),
page,
now,
)),
None if taker.state.held() => {
let state = taker.state.clone();
self.scroll_rests(&state, &heard_before, previous.at, previous.source);
}
None => {}
}
}
let moved = std::mem::take(&mut previous.moved);
Self::pages_of_moved(&mut asides, moved, taker.as_ref().map(|taker| &taker.state), now);
let own = taker.as_ref().and_then(|taker| {
let at = asides.iter().position(|aside| aside.state.ptr_eq(&taker.state))?;
Some(asides.remove(at))
});
if let (Some(taker), Some(_)) = (&taker, &own) {
taker.state.set_page_target(None);
}
let began = match (&taker, previous.caught_page, own) {
(Some(_), _, Some(own)) => own.page.to,
(Some(_), Some(page), None) 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,
moving: false,
caught: false,
source: ScrollSource::Finger,
at: (lx, ly),
vertical,
moved: Vec::new(),
asides,
};
self.mark_touch_scroll_moved();
}
pub(super) fn touch_scrolled(&mut self, lists: &[(NodeId, ScrollState)]) {
let scroll = &mut self.touch_scroll;
for (node, state) in lists {
let own = scroll.taker.as_ref().is_some_and(|taker| taker.state.ptr_eq(state));
if !own && !scroll.moved.iter().any(|(_, moved)| moved.ptr_eq(state)) {
scroll.moved.push((*node, state.clone()));
}
}
}
fn pages_of_moved(
asides: &mut Vec<Aside>,
moved: Vec<(NodeId, ScrollState)>,
own: Option<&ScrollState>,
now: Instant,
) {
for (node, state) in moved {
if !state.paging()
|| own.is_some_and(|own| own.ptr_eq(&state))
|| asides.iter().any(|aside| aside.state.ptr_eq(&state))
{
continue;
}
let offset = (state.scroll_x(), state.scroll_y());
let viewport = (state.viewport_width(), state.viewport_height());
let ends = (
(state.content_width() - viewport.0).max(0.0),
(state.content_height() - viewport.1).max(0.0),
);
let to = (
page_target(offset.0, offset.0, viewport.0, ends.0, 0.0),
page_target(offset.1, offset.1, viewport.1, ends.1, 0.0),
);
if to != offset {
asides.push(Aside::to(state, Some(node), to, now));
}
}
}
fn touch_scroll_starts(&mut self) {
let Some(taker) = &self.touch_scroll.taker else {
return;
};
if taker.state.held() {
return;
}
taker.state.set_held(true);
tracing::debug!(
target: "lurq::scroll",
x = taker.state.scroll_x(),
y = taker.state.scroll_y(),
page = ?taker.state.page(),
"start"
);
let at = self.touch_scroll.at;
for target in self.touch_scroll_targets.clone() {
self.dispatch_scroll_handlers_for_node(target, at.0, at.1, 0.0, 0.0, ScrollPhase::Start, ScrollSource::Finger);
}
}
pub(super) fn touch_scroll_rest(&mut self, now: Instant) {
if !self.touch_scroll.moving && !self.touch_scroll.caught && !self.touch_scroll.moved.is_empty() {
let scroll = &mut self.touch_scroll;
let moved = std::mem::take(&mut scroll.moved);
let own = scroll.taker.as_ref().map(|taker| taker.state.clone());
Self::pages_of_moved(&mut scroll.asides, moved, own.as_ref(), now);
self.needs_redraw = true;
}
let scroll = &self.touch_scroll;
let Some(taker) = &scroll.taker else {
return;
};
if scroll.busy() || !taker.state.held() {
return;
}
let (state, at, source) = (taker.state.clone(), scroll.at, scroll.source);
let heard = self.touch_scroll_targets.clone();
self.scroll_rests(&state, &heard, at, source);
}
fn touch_scroll_node(&self) -> Option<NodeId> {
let taker = self.touch_scroll.taker.as_ref()?;
let root = self.root.as_ref()?;
self
.touch_scroll
.around
.first()
.copied()
.filter(|id| find_node_by_id(root, *id).is_some())
.or_else(|| find_scroll_node_id_by_state(root, &taker.state))
}
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;
}
taker.state.set_page_target(Some(to));
tracing::debug!(
target: "lurq::scroll",
page = ?taker.state.target_page(),
from = ?taker.state.rested_page(),
"snapping to page"
);
self.touch_scroll.source = ScrollSource::Snap;
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);
if let Some(taker) = &self.touch_scroll.taker
&& taker.axes != (true, true)
{
if self.touch_scroll.vertical {
change.0 = 0.0;
} else {
change.1 = 0.0;
}
}
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);
let source = if momentum {
ScrollSource::Momentum
} else {
ScrollSource::Finger
};
self.touch_scroll.source = source;
self.touch_scroll.moving = !matches!(phase, ScrollPhase::End);
self.touch_scroll_starts();
self.touch_scroll_latched = true;
let input = ScrollInput {
animated: false,
notched: false,
modifiers: MouseModifiers::default(),
source,
};
self.scroll_event(x, y, -change.0, -change.1, phase, input);
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 let Some(to_top) = self.touch_scroll.to_top.take() {
let list = to_top.around.first().copied();
self.scroll_rests(&to_top.state, list.as_slice(), (0.0, 0.0), ScrollSource::Code);
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);
self.touch_scroll.caught = true;
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));
self.touch_scroll.caught = true;
true
}
pub(super) fn touch_scroll_caught(&mut self) {
self.touch_scroll.caught = self.touch_scroll.taker.is_some();
}
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);
self.touch_scroll.caught = false;
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);
if let Some(page) = &self.touch_scroll.page {
taker.state.set_scroll(page.to.0, page.to.1);
}
}
self.touch_scroll.spring = None;
self.touch_scroll.page = None;
self.touch_scroll.caught = false;
self.touch_scroll.pull = (0.0, 0.0);
state.set_held(true);
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 springs = self.touch_spring_tick(now);
self.touch_scroll_rest(now);
let asides = self.touch_asides_tick(now);
springs || to_top || asides
}
fn touch_asides_tick(&mut self, now: Instant) -> bool {
if self.touch_scroll.asides.is_empty() {
return false;
}
let mut going = Vec::new();
let mut moved = false;
for mut aside in std::mem::take(&mut self.touch_scroll.asides) {
let (to, rests) = aside.page.at(now);
let state = aside.state.clone();
let was = (state.scroll_x(), state.scroll_y());
let was_end = (state.content_height() - state.viewport_height()).max(0.0);
state.set_scroll(to.0, to.1);
aside.node = self.root.as_ref().and_then(|root| {
aside
.node
.filter(|id| find_node_by_id(root, *id).is_some())
.or_else(|| find_scroll_node_id_by_state(root, &state))
});
if let (Some(root), Some(node)) = (&self.root, aside.node) {
mark_scroll_layout_dirty(root, node);
}
if let Some(node) = aside.node
&& (state.scroll_x(), state.scroll_y()) != was
{
moved = true;
self.dispatch_scroll_handlers_for_node(node, 0.0, 0.0, 0.0, 0.0, ScrollPhase::Scroll, ScrollSource::Snap);
self.dispatch_scroll_reach_handlers_for_node(
node,
0.0,
0.0,
0.0,
0.0,
ScrollPhase::Scroll,
was.1,
was_end,
ScrollSource::Snap,
);
}
if rests {
let heard: Vec<NodeId> = aside.node.into_iter().collect();
self.scroll_rests(&state, &heard, (0.0, 0.0), ScrollSource::Snap);
} else {
if aside.page.arrived(to, &state) {
self.page_arrives(&state, aside.node);
}
going.push(aside);
}
}
self.needs_redraw = true;
if moved {
self.apply_reactive_updates_after_event();
}
let still = !going.is_empty();
self.touch_scroll.asides = going;
still
}
fn touch_spring_tick(&mut self, now: Instant) -> bool {
let (Some(taker), Some(spring)) = (&self.touch_scroll.taker, &self.touch_scroll.spring) else {
return false;
};
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
}
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);
let was = to_top.state.scroll_y();
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;
let (state, list) = (to_top.state.clone(), to_top.around.first().copied());
let list = self.root.as_ref().and_then(|root| {
list
.filter(|id| find_node_by_id(root, *id).is_some())
.or_else(|| find_scroll_node_id_by_state(root, &state))
});
if let Some(list) = list
&& state.scroll_y() != was
{
self.dispatch_scroll_handlers_for_node(list, 0.0, 0.0, 0.0, 0.0, ScrollPhase::Scroll, ScrollSource::Code);
}
if done {
self.touch_scroll.to_top = None;
self.scroll_rests(&state, list.as_slice(), (0.0, 0.0), ScrollSource::Code);
}
!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 (to, rests) = page.at(now);
let (was, was_end) = (taker.offsets(), taker.ends().1);
taker.state.set_scroll(to.0, to.1);
let arrived = (!rests && page.arrived(to, &taker.state)).then(|| taker.state.clone());
if rests {
self.touch_scroll.page = None;
}
let moved = taker.offsets() != was;
self.mark_touch_scroll_moved();
if moved && let Some(list) = self.touch_scroll_node() {
let at = self.touch_scroll.at;
self.dispatch_scroll_handlers_for_node(list, at.0, at.1, 0.0, 0.0, ScrollPhase::Scroll, ScrollSource::Snap);
self.dispatch_scroll_reach_handlers_for_node(
list,
at.0,
at.1,
0.0,
0.0,
ScrollPhase::Scroll,
was.1,
was_end,
ScrollSource::Snap,
);
self.apply_reactive_updates_after_event();
}
if let Some(state) = arrived {
let list = self.touch_scroll_node();
self.page_arrives(&state, list);
}
!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_scroll.asides.is_empty()
|| 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();
}
}