Struct Stack 

pub struct Stack { /* private fields */ }

A collection of static views. See stack and stack_from_iter.

The children of a stack can still get reactive updates.

Implementations

impl Stack

pub fn new(children: impl IntoViewIter) -> Self

Creates a new stack from any type that implements IntoViewIter.

This accepts arrays, tuples, vectors, slices, and iterators of views.

Example

use floem::views::*;

// From array
Stack::new([text("child 1"), text("child 2")]);

// From tuple (heterogeneous types)
Stack::new((text("label"), button("click")));

// From vec
Stack::new(vec![text("a"), text("b"), text("c")]);

// From iterator
Stack::new((0..5).map(|i| text(i)).collect::<Vec<_>>());

pub fn with_id(id: ViewId, children: impl IntoViewIter) -> Self

Creates a new stack with a specific ViewId from a tuple of views.

This is useful for lazy view construction where the ViewId is created before the view itself.

Example

use floem::{ViewId, views::Stack};

let id = ViewId::new();
Stack::with_id(id, ("child 1", "child 2"));

pub fn from_iter<V: IntoView + 'static>( children: impl IntoIterator<Item = V>, ) -> Self

Creates a new stack from an iterator of views.

Example

use floem::views::*;

Stack::from_iter((0..5).map(|i| text(i)));

pub fn from_iter_with_id<V: IntoView + 'static>( id: ViewId, children: impl IntoIterator<Item = V>, direction: Option<FlexDirection>, ) -> Self

Creates a new stack with a specific ViewId from an iterator of views.

This is useful for lazy view construction where the ViewId is created before the view itself. Unlike with_id, this method pre-converts all views before setting children, avoiding potential RefCell borrow conflicts.

Example

use floem::{ViewId, views::*};

let id = ViewId::new();
Stack::from_iter_with_id(id, (0..5).map(|i| text(i)), None);

pub fn horizontal(children: impl IntoViewIter) -> Self

Creates a new horizontal stack (row direction).

Example

use floem::views::*;

Stack::horizontal((text("left"), text("right")));

pub fn vertical(children: impl IntoViewIter) -> Self

Creates a new vertical stack (column direction).

Example

use floem::views::*;

Stack::vertical((text("top"), text("bottom")));

pub fn horizontal_from_iter<V: IntoView + 'static>( children: impl IntoIterator<Item = V>, ) -> Self

Creates a new horizontal stack from an iterator of views.

Example

use floem::views::*;

Stack::horizontal_from_iter((0..5).map(|i| text(i)));

pub fn vertical_from_iter<V: IntoView + 'static>( children: impl IntoIterator<Item = V>, ) -> Self

Creates a new vertical stack from an iterator of views.

Example

use floem::views::*;

Stack::vertical_from_iter((0..5).map(|i| text(i)));

pub fn add_class_by_idx(self, class: impl Fn(usize) -> StyleClassRef) -> Self

Trait Implementations

impl View for Stack

fn id(&self) -> ViewId

fn view_style(&self) -> Option<Style>

fn debug_name(&self) -> Cow<'static, str>

fn update(&mut self, _cx: &mut UpdateCx<'_>, state: Box<dyn Any>)

Use this method to react to changes in view-related state. You will usually send state to this hook manually using the View’s Id handle

fn view_class(&self) -> Option<StyleClassRef>

fn style_pass(&mut self, cx: &mut StyleCx<'_>)

Use this method to style the view’s children.

fn layout(&mut self, cx: &mut LayoutCx<'_>) -> NodeId

Use this method to layout the view’s children. Usually you’ll do this by calling LayoutCx::layout_node.

fn compute_layout(&mut self, cx: &mut ComputeLayoutCx<'_>) -> Option<Rect>

Responsible for computing the layout of the view’s children.

fn event_before_children( &mut self, cx: &mut EventCx<'_>, event: &Event, ) -> EventPropagation

fn event_after_children( &mut self, cx: &mut EventCx<'_>, event: &Event, ) -> EventPropagation

fn paint(&mut self, cx: &mut PaintCx<'_>)

View-specific implementation. Will be called in PaintCx::paint_view. Usually you’ll call paint_view for every child view. But you might also draw text, adjust the offset, clip or draw text.

fn scroll_to( &mut self, cx: &mut WindowState, target: ViewId, rect: Option<Rect>, ) -> bool

Scrolls the view and all direct and indirect children to bring the target view to be visible. Returns true if this view contains or is the target.