Struct ScrollArea 

pub struct ScrollArea<S, M> { /* private fields */ }

A vertical viewport that hosts arbitrary interactive ratcn descendants.

One column is reserved at the right for the scrollbar. The content closure receives the remaining width and exactly content_height logical rows, however many of them are visible. The scrollbar is an indicator of where the view sits.

The offset is the area’s own until scroll binds it. Wheel, Page Up, Page Down, Home, and End reach descendants first; what none of them handles scrolls the area. An event that leaves the offset where it is — every one of these keys at an edge, and a horizontal wheel — bubbles on to the app, which keeps app hotkeys on those keys alive. The area is a fallback focus stop while it holds no focusable descendant, so keyboard scrolling works for paint-only content.

Focus moving to a descendant the viewport clips scrolls that descendant into view.

Panics

A ScrollArea inside another ScrollArea panics, as does content larger than 262,144 cells, as does a single paint inside one covering more than that.

ctx.component(
    "settings",
    ScrollArea::new(40).content(|ctx| {
        ctx.component(
            "save",
            Button::new("Save").on_press(|| Msg::Saved),
            Rect::new(0, 0, 10, 3),
        );
    }),
    Rect::new(0, 0, 30, 10),
);

Implementations

impl<S, M> ScrollArea<S, M>

pub fn new(content_height: u16) -> Self

A viewport over content_height logical rows.

pub fn scroll( self, read: impl Fn(&S) -> u16 + 'static, on_change: impl Fn(u16) -> M + 'static, ) -> Self

Bind the first visible content row to app state.

read is consulted for every event, so repeated wheel or page events compose before a redraw, and on_change carries each new offset to the app’s update. Left unbound, the area keeps the offset itself and emits nothing.

A reveal moves the view on its own, without a message; the next offset the area emits starts from where the reveal left it.

pub fn content( self, content: impl FnOnce(&mut DeclareCtx<'_, S, M>) + 'static, ) -> Self

Declare the viewport’s descendants in their full logical content area.

pub fn style(self, style: impl Fn(&Theme) -> ScrollAreaStyle + 'static) -> Self

Replace the theme-derived scrollbar style.

pub const fn hover_focus(self) -> Self

Make pointer motion choose between the content’s direct child scopes.

This is opt-in so ordinary scrollable forms leave keyboard focus alone when the pointer drifts. It suits a scrollable pane or tile grid whose direct children are the regions focus should follow.

Trait Implementations

impl<S: 'static, M: 'static> Component<S, M> for ScrollArea<S, M>

fn declare(&mut self, ctx: &mut DeclareCtx<'_, S, M>)

Declare the component: lay out its area, declare its descendants, and record whatever handle_event will need to read back.

fn handle_event( &mut self, event: &Event, state: &S, ctx: &mut EventCtx<'_>, ) -> EventResult<M>

Offer this component an event.

fn reveal_in_viewport( &mut self, target: Rect, state: &S, ctx: &mut EventCtx<'_>, )

Bring target into view inside this component’s viewport.

fn scope_options(&self) -> ScopeOptions

The scope this component opens around its descendants. Read once, before declare, so it cannot depend on paint.

fn prepare(&mut self, _state: &State)

Prepare this component from the state it is being declared with.

fn interaction_area(&self, area: Rect) -> Rect

Return the area used for focus, hit-testing, and event routing.

fn paint(&mut self, _ctx: &mut PaintCtx<'_, State>)

Paint the component. ctx carries the paint surface, area, app state, theme, and interaction state.

impl<S, M> Debug for ScrollArea<S, M>

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

Formats the value using the given formatter.