Struct ScrollView 

pub struct ScrollView<State: 'static> { /* private fields */ }

A declarative vertical scroll surface. See the module docs.

Implementations

impl<State: 'static> ScrollView<State>

pub fn new<V: View<State>>(child: V) -> Self

Wrap child in a vertical scroll view.

pub fn on_scroll<F: Fn(&mut State, ScrollInfo) + 'static>( self, callback: F, ) -> Self

Observe scroll position changes. The callback receives a ScrollInfo snapshot each time the offset or overscroll changes due to input (drag, wheel), and — one event late — for fling/settle motion driven at paint time (the paint pass carries no EventCtx, so the notification is recorded and delivered on the next event, the same controlled-component convention the interactive widgets follow). A Cancel clears any pending notification without firing it.

pub fn on_refresh_release<F: Fn(&mut State) + 'static>( self, callback: F, ) -> Self

The pull-to-refresh trigger: fires on pointer Up when the surface was pulled past the top by more than [REFRESH_TRIGGER_PX] (post-resistance), so an app gets a single “release past threshold” signal without reimplementing overscroll thresholding. Never fires on a Cancel.

pub fn physics(self, physics: impl ScrollPhysics + 'static) -> Self

Install a custom ScrollPhysics strategy — the pluggable drag-mapping/boundary-rejection/post-release-motion contract described in crate::physics, with the platform-parity physics (crate::physics::parity’s Bouncing/Clamping/ AlwaysScrollable/NeverScrollable) and the pre-seam RubberBand as the built-in implementations.

use frust_widgets::{NeverScrollable, ScrollView, scroll_view, text};
let view: ScrollView<()> = scroll_view(text("hi")).physics(NeverScrollable::new());

Build/rebuild semantics

A view built (or rebuilt) with .physics(...) installs it on the widget every time — like ScrollView::on_scroll’s erased callback, a trait object isn’t comparable, so this reinstalls unconditionally rather than diffing. A view built (or rebuilt) without .physics(...) leaves whatever the widget already has installed untouched: a fresh build still starts the widget at crate::physics::default_physics (the widget’s own constructor default), but rebuilding from a .physics(...)-carrying view to a plain one does not revert it — there is no spelling for “go back to the default” versus “no opinion this rebuild”, and this picks the latter, the same shape ScrollWidget::effect already followed before this method existed.

Defaults to the platform-adaptive physics (crate::physics::default_physics — Android clamping, elsewhere bouncing) if never called; .physics(RubberBand::new()) is how an app asks for the pre-seam rubber-band feel instead.

pub fn overscroll_effect(self, effect: OverscrollEffect) -> Self

Select how past-edge pull is visualized. See OverscrollEffect (crate::physics::effect) for the full contract: move the content with the pull, paint a Material-3-Expressive edge stretch about the held edge, or show no visual at all.

use frust_widgets::{OverscrollEffect, ScrollView, scroll_view, text};
let view: ScrollView<()> = scroll_view(text("hi")).overscroll_effect(OverscrollEffect::Stretch);

Plain view-owned data, unlike ScrollView::physics: every build/rebuild carries the current value down to ScrollWidget::effect unconditionally.

Defaults to the effect paired with the platform’s default physics (crate::physics::default_overscroll_effect): the M3E OverscrollEffect::Stretch on Android, translate overscroll (OverscrollEffect::Translate) everywhere else.

pub fn controller(self, controller: ScrollController) -> Self

Attach a ScrollController — the handle app code drives this surface with (ScrollController::jump_to) and reads it through (ScrollController::offset/ScrollController::max_offset/ ScrollController::on_change) from outside any dispatch.

use frust_widgets::{ScrollController, ScrollView, scroll_view, text};
let controller = ScrollController::new();
let view: ScrollView<()> = scroll_view(text("hi")).controller(controller.clone());

Build/rebuild semantics

A build binds the handle, taking it over from any other surface that held it. A rebuild with the same handle keeps the binding — and, when another surface has since taken the handle over, leaves it there rather than taking it back, so two live views naming one handle never trade it every frame (it re-binds only once the handle is unattached again). A rebuild with a different handle binds that one; a rebuild with none detaches. Dropping the widget detaches the handle it still holds.

Trait Implementations

impl<State: 'static> View<State> for ScrollView<State>

type Element = ScrollWidget

The retained widget this view produces.

fn build(&self, ctx: &mut BuildCtx<'_>) -> ScrollWidget

Materialise a fresh widget for this view.

fn rebuild( &self, prev: &Self, element: &mut ScrollWidget, ctx: &mut BuildCtx<'_>, ) -> ChangeFlags

Reconcile prev (the previous view of the same type) against the live element, mutating it in place and reporting what changed.

fn teardown(&self, element: &mut ScrollWidget, ctx: &mut BuildCtx<'_>)

Tear down element when this view is being removed.

fn message(&self, _element: &mut Self::Element, _state: &mut State)

Deliver an event message to this view, mutating application state.