Struct ScrollView 

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

A declarative vertical scroll surface. See the module docs.

Implementations

impl<State> ScrollView<State>

where State: 'static,

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

where V: View<State>,

Wrap child in a vertical scroll view.

pub fn on_scroll<F>(self, callback: F) -> ScrollView<State>

where F: Fn(&mut State, ScrollInfo) + 'static,

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>(self, callback: F) -> ScrollView<State>

where F: Fn(&mut State) + 'static,

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) -> ScrollView<State>

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) -> ScrollView<State>

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.

Trait Implementations

impl<State> View<State> for ScrollView<State>

where State: 'static,

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: &ScrollView<State>, 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.