Struct ScrollableBehavior 

pub struct ScrollableBehavior { /* private fields */ }

The whole of what a widget must do to become scrollable, as one value it installs onto its HandlerSet.

Two halves, and both matter. The on_scroll handler is the arithmetic; the PanClaim is what puts the node on the claimant chain a synthesised pan walks. Installing one without the other yields a surface that scrolls on a wheel and ignores a finger, which is exactly the state this crate was in before this module.

Implementations

impl ScrollableBehavior

pub fn new(axes: ScrollableAxes) -> Self

A behaviour over axes, with a scroller of its own.

A surface that must reach the scroller from its layout pass (to publish its viewport, which is what the rubber-band curve is a fraction of) keeps its own handle and passes it to with_scroller instead, so the physics survives a rebuild.

pub fn with_scroller(self, scroller: Rc<RefCell<KineticScroller>>) -> Self

Use the caller’s scroller rather than the one new made.

pub fn axes(self, axes: PanAxes) -> Self

Which axes a finger may pan.

pub fn overscroll(self, behavior: OverscrollBehavior) -> Self

Whether a boundary scroll chains outward or is absorbed.

pub fn rubber_band(self, on: bool) -> Self

Follow the finger past the end with decreasing gain. See ScrollHandlingOptions::rubber_band for why this is off by default.

pub fn overscroll_style(self, style: OverscrollStyle) -> Self

Which overscroll feel to use when the band is on.

pub fn smooth(self, on: bool) -> Self

Whether a wheel notch tweens to its target.

pub fn smooth_duration(self, duration: Duration) -> Self

How long that tween lasts.

pub fn line_height(self, pixels: f32) -> Self

Pixels one line of a ScrollDelta::Lines notch is worth.

pub fn pan_devices(self, devices: PointerKindMask) -> Self

Which pointer kinds may pan this surface.

pub fn reduced_motion(self, reduced: bool) -> Self

prefers-reduced-motion, read from the build context.

pub fn physics(self, physics: ScrollPhysicsTokens) -> Self

The theme’s scroll-physics constants, for the rubber-band curve.

pub fn before( self, arm: impl Fn(&WidgetEvent, &mut EventContext<'_>) -> Option<EventResponse> + 'static, ) -> Self

An arm the installed handler runs first, for every event.

The answer is an Option, and the two halves of it are different questions:

• None — “not mine”. The shared treatment then runs on the same, unmodified event. This is what an observing arm returns: a surface doing per-scroll bookkeeping before the delta lands looks, records, and declines.
• Some(r) — “this event is mine, and r is the surface’s answer to it”. The shared treatment does not run at all. Both a surface’s own scroll-adjacent events (ScrollIntoView is the usual one) and an arm that rewrote the event and fed the rewrite to handle_scroll_event itself take this branch — including when the rewrite could not move, where the answer is Some(Ignored) so the whole original event chains outward.

That last case is why this is an Option and not an EventResponse. A Handled-means-short-circuit rule cannot express “I consumed this event and the answer is Ignored”, so a remapping arm — the tables’ Shift+wheel — would fall through and have the shared handler apply the original delta on top of the remapped one it just declined.

pub fn after( self, arm: impl Fn(&WidgetEvent, EventResponse, &mut EventContext<'_>) + 'static, ) -> Self

An arm the installed handler runs last, once the delta has landed.

It sees the event and the answer the surface is about to give, and can change neither: contradicting the boundary answer is how a chain stops working. It is for the bookkeeping a surface can only do after the offset moved — asking for a repaint being the one that matters, on a surface whose offset signals are read at paint rather than bound to the node.

It runs on every path, including the one where a before arm claimed the event — a before arm that answers Handled has moved the offset itself, which is exactly the case this arm exists to notice.

pub fn scroller(&self) -> Rc<RefCell<KineticScroller>>

The scroller this behaviour will use, for a surface that must publish its viewport into it from layout.

pub fn options(&self) -> ScrollHandlingOptions

The options this behaviour resolved to. Exposed for a surface that wants to answer the same boundary question from a second call site (a keyboard page, an AT scroll action).

pub fn install(self, handlers: HandlerSet) -> HandlerSet

Attach the pan claim and the scroll handler to handlers.

Trait Implementations

impl Debug for ScrollableBehavior

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.