Struct LayoutStyle 

pub struct LayoutStyle {

    pub display: Display,
    pub overflow: (Overflow, Overflow),
    pub scrollbar_width: f32,
    pub position: Position,
    pub inset: Rect<LengthPercentageAuto>,
    pub size: Vector2<Dimension>,
    pub min_size: Vector2<Dimension>,
    pub max_size: Vector2<Dimension>,
    pub aspect_ratio: Option<f32>,
    pub margin: Rect<LengthPercentageAuto>,
    pub padding: Rect<LengthPercentage>,
    pub border: Rect<LengthPercentage>,
    pub align_items: Option<AlignItems>,
    pub align_self: Option<AlignSelf>,
    pub justify_items: Option<AlignItems>,
    pub justify_self: Option<AlignSelf>,
    pub align_content: Option<AlignContent>,
    pub justify_content: Option<JustifyContent>,
    pub gap: Vector2<LengthPercentage>,
    pub flex_direction: FlexDirection,
    pub flex_wrap: FlexWrap,
    pub flex_basis: Dimension,
    pub flex_grow: f32,
    pub flex_shrink: f32,
    pub grid_auto_flow: GridAutoFlow,
    pub grid_row: Line<GridPlacement>,
    pub grid_column: Line<GridPlacement>,
}

Defines different aspects and properties of a widget layout.

Fields

display: Display

What layout strategy should be used?

overflow: (Overflow, Overflow)

How children overflowing their container should affect layout.

scrollbar_width: f32

How much space (in points) should be reserved for scrollbars.

position: Position

What should the position value of this struct use as a base offset?

inset: Rect<LengthPercentageAuto>

How should the position of this element be tweaked relative to the layout defined?

size: Vector2<Dimension>

Sets the initial size of the item.

min_size: Vector2<Dimension>

Controls the minimum size of the item.

max_size: Vector2<Dimension>

Controls the maximum size of the item.

aspect_ratio: Option<f32>

Sets the preferred aspect ratio for the item

The ratio is calculated as width divided by height.

margin: Rect<LengthPercentageAuto>

How large should the margin be on each side?

padding: Rect<LengthPercentage>

How large should the padding be on each side?

border: Rect<LengthPercentage>

How large should the border be on each side?

align_items: Option<AlignItems>

How this node’s children aligned in the cross/block axis?

align_self: Option<AlignSelf>

How this node should be aligned in the cross/block axis Falls back to the parents AlignItems if not set.

justify_items: Option<AlignItems>

How this node’s children should be aligned in the inline axis.

justify_self: Option<AlignSelf>

How this node should be aligned in the inline axis Falls back to the parents JustifyItems if not set.

align_content: Option<AlignContent>

How should content contained within this item be aligned in the cross/block axis?

justify_content: Option<JustifyContent>

How should content contained within this item be aligned in the main/inline axis?

gap: Vector2<LengthPercentage>

How large should the gaps between items in a grid or flex container be?

flex_direction: FlexDirection

Which direction does the main axis flow in?

flex_wrap: FlexWrap

Should elements wrap, or stay in a single line?

flex_basis: Dimension

Sets the initial main axis size of the item.

flex_grow: f32

The relative rate at which this item grows when it is expanding to fill space.

0.0 is the default value, and this value must be positive.

flex_shrink: f32

The relative rate at which this item shrinks when it is contracting to fit into space.

1.0 is the default value, and this value must be positive.

grid_auto_flow: GridAutoFlow

Controls how items get placed into the grid for auto-placed items.

grid_row: Line<GridPlacement>

Defines which row in the grid the item should start and end at.

grid_column: Line<GridPlacement>

Defines which column in the grid the item should start and end at.

Trait Implementations

impl Clone for LayoutStyle

fn clone(&self) -> LayoutStyle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for LayoutStyle

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

Formats the value using the given formatter.

impl Default for LayoutStyle

fn default() -> Self

Returns the “default value” for a type.

impl From<LayoutStyle> for Style

fn from(value: LayoutStyle) -> Self

Converts to this type from the input type.

impl PartialEq for LayoutStyle

fn eq(&self, other: &LayoutStyle) -> 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 LayoutStyle