Enum zng::scroll::LazyMode

pub enum LazyMode {
    Disabled,
    Enabled {
        placeholder: WidgetFn<()>,
        deinit: bool,
        intersect: ScrollMode,
    },
}

Lazy loading mode of a widget.

See lazy property for more details.

Variants

Disabled

Node always loaded.

Enabled

Node lazy loaded.

Fields

placeholder: WidgetFn<()>

Function that instantiates the node that replaces the widget when it is not in the init viewport.

All node methods are called on the placeholder, except the render methods, it should efficiently estimate the size of the inited widget.

deinit: bool

If the node is deinited when is moved out of the viewport.

If false the node stays loaded after the first lazy load.

If true the placeholder size is always used, this is to avoid the app entering a “flickering” loop when the actual bounds are different causing an immediate deinit. An error is logged if the placeholder size does not match.

intersect: ScrollMode

The scroll directions that are considered for intersection with the viewport.

If set to ScrollMode::VERTICAL the widget is inited if it intersects on the vertical dimension only, even if it is not actually in the viewport due to horizontal offset, and if deinit is flagged only the placeholder height is enforced, the width can be different from the actual.

If set to ScrollMode::NONE this value is ignored, behaving like ScrollMode::PAN.

Implementations

impl LazyMode

pub fn lazy(placeholder: WidgetFn<()>) -> LazyMode

Enable lazy mode with a node that estimates the widget size.

The widget function must produce a node that is used as the layout placeholder for the actual widget content.

The widget will init when the placeholder stops being culled by render, and deinit when it starts being culled. Note that in this mode the placeholder size is always used as the widget size, see the deinit docs in LazyMode::Enabled for more details.

See FrameBuilder::auto_hide_rect for more details about render culling.

pub fn lazy_vertical(placeholder: WidgetFn<()>) -> LazyMode

Like lazy, but only considers the height and vertical offset to init and deinit. Like lazy the placeholder height is enforced, but the width is allowed to change between placeholder and actual.

Note that if the widget is inlined the full size of the widget placeholder is enforced like lazy, the widget will still init and deinit considering only the vertical intersection.

pub fn lazy_horizontal(placeholder: WidgetFn<()>) -> LazyMode

Like lazy, but only considers the width and horizontal offset to init and deinit. Like lazy the placeholder width is enforced, but the height is allowed to change between placeholder and actual.

Note that if the widget is inlined the full size of the widget placeholder is enforced like lazy, the widget will still init and deinit considering only the horizontal intersection.

pub fn once(placeholder: WidgetFn<()>) -> LazyMode

Like lazy but the widget stays inited after the first, even if it is culled by render it will be present in the UI tree.

Note that this mode allows the actual size to be different from the placeholder size, so it can be used for items that can’t estimate their own size exactly.

This mode is only recommended for items that are “heavy” to init, but light after, otherwise the app will show degraded performance after many items are inited.

pub fn once_vertical(placeholder: WidgetFn<()>) -> LazyMode

Like once, but only considers the height and vertical offset to init.

pub fn once_horizontal(placeholder: WidgetFn<()>) -> LazyMode

Like once, but only considers the width and horizontal offset to init.

pub fn is_enabled(&self) -> bool

If lazy init is mode.

pub fn is_disabled(&self) -> bool

If lazy init is disabled.

Trait Implementations

impl Clone for LazyMode

fn clone(&self) -> LazyMode

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for LazyMode

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

Formats the value using the given formatter.

impl PartialEq for LazyMode

fn eq(&self, other: &LazyMode) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for LazyMode