Struct Node

pub struct Node {

    pub width: Size,
    pub height: Size,
    pub minimum_width: Size,
    pub minimum_height: Size,
    pub maximum_width: Size,
    pub maximum_height: Size,
    pub visible_width: VisibleSize,
    pub visible_height: VisibleSize,
    pub main_alignment: Alignment,
    pub cross_alignment: Alignment,
    pub padding: Gaps,
    pub margin: Gaps,
    pub offset_x: Length,
    pub offset_y: Length,
    pub direction: Direction,
    pub position: Position,
    pub content: Content,
    pub has_layout_references: bool,
    pub contains_text: bool,
    pub spacing: Length,
}

Node layout configuration

Fields

width: Size

Dimentions

height: Size

minimum_width: Size

minimum_height: Size

maximum_width: Size

maximum_height: Size

visible_width: VisibleSize

visible_height: VisibleSize

main_alignment: Alignment

cross_alignment: Alignment

padding: Gaps

Inner padding

margin: Gaps

Inner margin

offset_x: Length

Inner position offsets

offset_y: Length

direction: Direction

Direction in which it’s inner Nodes will be stacked

position: Position

Position config

content: Content

has_layout_references: bool

A Node might depend on inner sizes but have a fixed position, like scroll views.

contains_text: bool

spacing: Length

Implementations

impl Node

pub fn new() -> Self

Create a Node with the default values

pub fn from_size_and_direction( width: Size, height: Size, direction: Direction, ) -> Self

Construct a new Node given a size and a direction

pub fn from_sizes( width: Size, height: Size, minimum_width: Size, minimum_height: Size, maximum_width: Size, maximum_height: Size, ) -> Self

Construct a new Node given some sizes

pub fn from_size_and_visible_size( width: Size, height: Size, visible_width: VisibleSize, visible_height: VisibleSize, ) -> Self

Construct a new Node given a size and a visible size

pub fn from_size_and_scroll( width: Size, height: Size, offset_x: Length, offset_y: Length, ) -> Self

Construct a new Node given a size and a scroll

pub fn from_size_and_padding(width: Size, height: Size, padding: Gaps) -> Self

Construct a new Node given a size and padding

pub fn from_size_and_alignments_and_direction( width: Size, height: Size, main_alignment: Alignment, cross_alignment: Alignment, direction: Direction, ) -> Self

Construct a new Node given a size, alignments and a direction

pub fn from_size_and_alignments_and_direction_and_spacing( width: Size, height: Size, main_alignment: Alignment, cross_alignment: Alignment, direction: Direction, spacing: Length, ) -> Self

Construct a new Node given a size, alignments, direction and spacing

pub fn from_size_and_margin(width: Size, height: Size, margin: Gaps) -> Self

Construct a new Node given a size and a direction

pub fn from_size_and_direction_and_margin( width: Size, height: Size, direction: Direction, margin: Gaps, ) -> Self

Construct a new Node given a size and a direction and some margin,

pub fn from_size_and_alignments_and_direction_and_padding( width: Size, height: Size, main_alignment: Alignment, cross_alignment: Alignment, direction: Direction, padding: Gaps, ) -> Self

Construct a new Node given a size, alignments and a direction

pub fn from_size_and_position( width: Size, height: Size, position: Position, ) -> Self

Construct a new Node given a size and a position

pub fn from_size_and_content( width: Size, height: Size, content: Content, ) -> Self

Construct a new Node given a size and content

pub fn from_size_and_direction_and_spacing( width: Size, height: Size, direction: Direction, spacing: Length, ) -> Self

Construct a new Node given a size and spacing

pub fn does_depend_on_inner(&self) -> bool

Has properties that depend on the inner Nodes?

pub fn do_inner_depend_on_parent(&self) -> bool

Has properties that make its children dependant on it?

Trait Implementations

impl Clone for Node

fn clone(&self) -> Node

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Node

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

Formats the value using the given formatter.

impl Default for Node

fn default() -> Node

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Node

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Node

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

fn scale(&mut self, scale_factor: f32)

fn scale_if_needed(&mut self, scale_factor: f32)

fn with_scale(&self, scale_factor: f32) -> Cow<'_, Self>

where Self: Clone,

impl Serialize for Node

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 Node