Struct taffy::style::Style

pub struct Style {

    pub display: Display,
    pub item_is_table: bool,
    pub box_sizing: BoxSizing,
    pub overflow: Point<Overflow>,
    pub scrollbar_width: f32,
    pub position: Position,
    pub inset: Rect<LengthPercentageAuto>,
    pub size: Size<Dimension>,
    pub min_size: Size<Dimension>,
    pub max_size: Size<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: Size<LengthPercentage>,
    pub grid_template_rows: Vec<TrackSizingFunction>,
    pub grid_template_columns: Vec<TrackSizingFunction>,
    pub grid_auto_rows: Vec<NonRepeatedTrackSizingFunction>,
    pub grid_auto_columns: Vec<NonRepeatedTrackSizingFunction>,
    pub grid_auto_flow: GridAutoFlow,
    pub grid_row: Line<GridPlacement>,
    pub grid_column: Line<GridPlacement>,
}

A typed representation of the CSS style information for a single node.

The most important idea in flexbox is the notion of a “main” and “cross” axis, which are always perpendicular to each other. The orientation of these axes are controlled via the [FlexDirection] field of this struct.

This struct follows the CSS equivalent directly; information about the behavior on the web should transfer directly.

Detailed information about the exact behavior of each of these fields can be found on MDN by searching for the field name. The distinction between margin, padding and border is explained well in this introduction to the box model.

If the behavior does not match the flexbox layout algorithm on the web, please file a bug!

Fields

display: Display

What layout strategy should be used?

item_is_table: bool

Whether a child is display:table or not. This affects children of block layouts. This should really be part of Display, but it is currently seperate because table layout isn’t implemented

box_sizing: BoxSizing

Should size styles apply to the content box or the border box of the node

overflow: Point<Overflow>

How children overflowing their container should affect layout

scrollbar_width: f32

How much space (in points) should be reserved for the scrollbars of Overflow::Scroll and Overflow::Auto nodes.

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: Size<Dimension>

Sets the initial size of the item

min_size: Size<Dimension>

Controls the minimum size of the item

max_size: Size<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 contained within this item be aligned in the main/inline axis

gap: Size<LengthPercentage>

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

grid_template_rows: Vec<TrackSizingFunction>

Defines the track sizing functions (heights) of the grid rows

grid_template_columns: Vec<TrackSizingFunction>

Defines the track sizing functions (widths) of the grid columns

grid_auto_rows: Vec<NonRepeatedTrackSizingFunction>

Defines the size of implicitly created rows

grid_auto_columns: Vec<NonRepeatedTrackSizingFunction>

Defined the size of implicitly created columns

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

Implementations

impl Style

pub const DEFAULT: Style = _

The Default layout, in a form that can be used in const functions

Trait Implementations

impl Clone for Style

fn clone(&self) -> Style

Returns a copy of the value.

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

Performs copy-assignment from source.

impl CoreStyle for Style

fn box_generation_mode(&self) -> BoxGenerationMode

Which box generation mode should be used

fn box_sizing(&self) -> BoxSizing

Which box do size styles apply to

fn overflow(&self) -> Point<Overflow>

How children overflowing their container should affect layout

fn scrollbar_width(&self) -> f32

How much space (in points) should be reserved for the scrollbars of Overflow::Scroll and Overflow::Auto nodes.

fn position(&self) -> Position

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

fn inset(&self) -> Rect<LengthPercentageAuto>

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

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

Sets the initial size of the item

fn min_size(&self) -> Size<Dimension>

Controls the minimum size of the item

fn max_size(&self) -> Size<Dimension>

Controls the maximum size of the item

fn aspect_ratio(&self) -> Option<f32>

Sets the preferred aspect ratio for the item The ratio is calculated as width divided by height.

fn margin(&self) -> Rect<LengthPercentageAuto>

How large should the margin be on each side?

fn padding(&self) -> Rect<LengthPercentage>

How large should the padding be on each side?

fn border(&self) -> Rect<LengthPercentage>

How large should the border be on each side?

fn is_block(&self) -> bool

Is block layout?

impl Debug for Style

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

Formats the value using the given formatter.

impl Default for Style

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Style

where Style: Default,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl GridContainerStyle for Style

type TemplateTrackList<'a> = &'a [TrackSizingFunction] where Self: 'a

The type returned by grid_template_rows and grid_template_columns

type AutoTrackList<'a> = &'a [MinMax<MinTrackSizingFunction, MaxTrackSizingFunction>] where Self: 'a

The type returned by grid_auto_rows and grid_auto_columns

fn grid_template_rows(&self) -> &[TrackSizingFunction]

Defines the track sizing functions (heights) of the grid rows

fn grid_template_columns(&self) -> &[TrackSizingFunction]

Defines the track sizing functions (widths) of the grid columns

fn grid_auto_rows(&self) -> &[NonRepeatedTrackSizingFunction]

Defines the size of implicitly created rows

fn grid_auto_columns(&self) -> &[NonRepeatedTrackSizingFunction]

Defined the size of implicitly created columns

fn grid_auto_flow(&self) -> GridAutoFlow

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

fn gap(&self) -> Size<LengthPercentage>

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

fn align_content(&self) -> Option<AlignContent>

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

fn justify_content(&self) -> Option<JustifyContent>

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

fn align_items(&self) -> Option<AlignItems>

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

fn justify_items(&self) -> Option<AlignItems>

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

fn grid_template_tracks( &self, axis: AbsoluteAxis, ) -> Self::TemplateTrackList<'_>

Get a grid item’s row or column placement depending on the axis passed

fn grid_align_content(&self, axis: AbstractAxis) -> AlignContent

Get a grid container’s align-content or justify-content alignment depending on the axis passed

impl GridItemStyle for &Style

fn grid_row(&self) -> Line<GridPlacement>

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

fn grid_column(&self) -> Line<GridPlacement>

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

fn align_self(&self) -> Option<AlignSelf>

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

fn justify_self(&self) -> Option<AlignSelf>

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

fn grid_placement(&self, axis: AbsoluteAxis) -> Line<GridPlacement>

Get a grid item’s row or column placement depending on the axis passed

impl PartialEq for Style

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

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Style