Struct Column

pub struct Column<T: WidgetList> {
    pub children: T,
    pub space_between: f64,
    pub main_axis_size: MainAxisSize,
    pub main_axis_alignment: MainAxisAlignment,
    pub cross_axis_size: CrossAxisSize,
    pub cross_axis_alignment: CrossAxisAlignment,
}

Fields

children: T

space_between: f64

main_axis_size: MainAxisSize

main_axis_alignment: MainAxisAlignment

cross_axis_size: CrossAxisSize

cross_axis_alignment: CrossAxisAlignment

Implementations

impl Column<()>

pub fn builder() -> Self

impl<WidgetList_: WidgetList> Column<WidgetList_>

pub fn children(self, children: impl WidgetList) -> Column<impl WidgetList>

List of children widgets to be laid out by the Column.

Note

See WidgetList for all the types that you can use as children.

pub fn main_axis_size(self, size: MainAxisSize) -> Self

Whether Column should take full available height or only the minimum to fit children.

Note

The default is MainAxisSize::Min.

If one of your children is flexible, MainAxisSize of this Column will be the same as if it was set to MainAxisSize::Max.

pub fn main_axis_alignment(self, alignment: MainAxisAlignment) -> Self

Specifies how Column should layout its children on the vertical axis.

Note

The default is MainAxisAlignment::Start.

pub fn cross_axis_size(self, size: CrossAxisSize) -> Self

Whether Column should take full available width or only the minimum to fit children.

Note

The default is CrossAxisSize::Min.

pub fn cross_axis_alignment(self, alignment: CrossAxisAlignment) -> Self

Specifies how Column should layout its children on the horizontal axis.

Note

The default is MainAxisAlignment::Start.

pub fn space_between(self, amount: f64) -> Self

Minimum amount of empty space added between children widgets.

Note

The default is 0.

Trait Implementations

impl<T: WidgetList> CheapEq for Column<T>

const CHEAP_TO_EQ: bool = false

This associated type is used to avoid recursive comparisons of the whole widget subtree (if one of the fields is itself a widget).

fn cheap_eq(&self, other: &Self) -> bool

impl<T: WidgetList> MultiChildWidget for Column<T>

fn build<'w>(&'w self, _: BuildContext<'w, Self>) -> Vec<Self::Widget<'w>>

fn layout(&self, ctx: RenderContext<'_, Self>, constraints: Constraints) -> Size

fn paint( &self, ctx: RenderContext<'_, Self>, canvas: &mut PaintContext<'_>, offset: &Offset, )

impl<T: WidgetList> RenderState for Column<T>

type State = ColumnRenderState

fn create_state(&self) -> Self::State

impl<T: WidgetList> Widget for Column<T>

fn unique_type(&self) -> TypeId

Implementation should return the same unique TypeId for given structure definition, even if that structure contains generic parameters. This is used to preserve state between generic widgets.

fn kind<'frui>(&'frui self) -> WidgetKind<'_>

impl<T: WidgetList> WidgetDerive for Column<T>

type Widget<'frui> = impl Widget + 'frui where Self: 'frui

Assuming this trait was derived through #[derive(WidgetKind)] this associated type should be derived automatically by the compiler. This requires that TAIT feature is enabled.