Struct Column 

pub struct Column<Key, W>
where
    Key: Copy + PartialEq,
{ /* private fields */ }

A container that distributes its contents vertically while keeping continuity.

Example

use iced::widget::{keyed_column, text};

enum Message {
    // ...
}

fn view(state: &State) -> impl Widget<Message> {
    keyed_column((0..=100).map(|i| {
        (i, text!("Item {i}"))
    }))
}

Implementations

impl<Key, W> Column<Key, W>

where Key: Copy + PartialEq,

pub fn new() -> Self

Creates an empty Column.

pub fn from_vecs(keys: Vec<Key>, children: Vec<W>) -> Self

Creates a Column from already allocated Vecs.

Keep in mind that the Column will not inspect the Vecs, which means it won’t automatically adapt to the sizing strategy of its contents.

If any of the children have a [Length::Fill] strategy, you will need to call Column::width or Column::height accordingly.

pub fn with_capacity(capacity: usize) -> Self

Creates a Column with the given capacity.

pub fn with_children(children: impl IntoIterator<Item = (Key, W)>) -> Self

where W: Meta,

Creates a Column with the given elements.

pub fn spacing(self, amount: impl Into<Pixels>) -> Self

Sets the vertical spacing between elements.

Custom margins per element do not exist in iced. You should use this method instead! While less flexible, it helps you keep spacing between elements consistent.

pub fn padding<P: Into<Padding>>(self, padding: P) -> Self

Sets the [Padding] of the Column.

pub fn width(self, width: impl Into<Length>) -> Self

Sets the width of the Column.

pub fn height(self, height: impl Into<Length>) -> Self

Sets the height of the Column.

pub fn align_items(self, align: Alignment) -> Self

Sets the horizontal alignment of the contents of the Column .

pub fn push(self, key: Key, child: W) -> Self

where W: Meta,

Adds an element to the Column.

pub fn push_maybe(self, key: Key, child: Option<W>) -> Self

where W: Meta,

Adds an element to the Column, if Some.

pub fn extend(self, children: impl IntoIterator<Item = (Key, W)>) -> Self

where W: Meta,

Extends the Column with the given children.

Trait Implementations

impl<Key, W> Default for Column<Key, W>

where Key: Copy + PartialEq,

fn default() -> Self

Returns the “default value” for a type.

impl<Key, W> Meta for Column<Key, W>

where Key: Copy + PartialEq,

fn is_void(&self) -> bool

Returns whether the [Widget] is Void.

impl<Key, W, Message, Theme, Renderer> Widget<Message, Theme, Renderer> for Column<Key, W>

where Renderer: Renderer, Key: Copy + PartialEq + 'static, W: Widget<Message, Theme, Renderer>,

fn tag(&self) -> Tag

Returns the Tag of the [Widget].

fn state(&self) -> State

Returns the State of the [Widget].

fn diff(&mut self, tree: &mut Tree)

Reconciles the [Widget] with the provided [Tree].

fn size(&self) -> Size<Length>

Returns the [Size] of the [Widget] in lengths.

fn layout(&mut self, tree: &mut Tree, renderer: &Renderer, limits: &Limits)

Lays out the [Widget].

fn operate( &mut self, tree: &mut Tree, layout: Layout, viewport: &Rectangle, renderer: &Renderer, operation: &mut dyn Operation, )

Applies an [Operation] to the [Widget].

fn update( &mut self, tree: &mut Tree, event: &Event, layout: Layout, cursor: Cursor, renderer: &Renderer, shell: &mut Shell<'_, Message>, viewport: &Rectangle, )

Processes a runtime Event.

fn mouse_interaction( &self, tree: &Tree, layout: Layout, cursor: Cursor, viewport: &Rectangle, renderer: &Renderer, ) -> Interaction

Returns the current [mouse::Interaction] of the [Widget].

fn draw( &self, tree: &Tree, renderer: &mut Renderer, theme: &Theme, style: &Style, layout: Layout, cursor: Cursor, viewport: &Rectangle, )

Draws the [Widget] using the associated Renderer.

fn overlay<'b>( &'b mut self, tree: &'b mut Tree, layout: Layout, renderer: &Renderer, viewport: &Rectangle, translation: Vector, window: Size, ) -> Vec<Element<'b, Message, Theme, Renderer>>

Returns the overlays of the [Widget].

fn _map<F, B>(self, f: F) -> Map<Self, F, Message>

where Self: Sized, F: Fn(Message) -> B,

Applies a transformation to the produced message of this [Widget], returning a [Map].

fn _boxed<'a>(self) -> Element<'a, Message, Theme, Renderer>

where Self: Sized + 'a,

Boxes this [Widget], turning it into a generic [Element].