Struct freya::prelude::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 main_alignment: Alignment,
    pub cross_alignment: Alignment,
    pub padding: Gaps,
    pub margin: Gaps,
    pub offset_x: Length<f32, Measure>,
    pub offset_y: Length<f32, Measure>,
    pub direction: DirectionMode,
    pub position: Position,
    pub content: Content,
    pub has_layout_references: bool,
    pub contains_text: bool,
    pub spacing: Length<f32, Measure>,
}

Node layout configuration

Fields

width: Size

Dimentions

height: Size

minimum_width: Size

minimum_height: Size

maximum_width: Size

maximum_height: Size

main_alignment: Alignment

cross_alignment: Alignment

padding: Gaps

Inner padding

margin: Gaps

Inner margin

offset_x: Length<f32, Measure>

Inner position offsets

offset_y: Length<f32, Measure>

direction: DirectionMode

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<f32, Measure>

Implementations

impl Node

pub fn new() -> Node

Create a Node with the default values

pub fn from_size_and_direction( width: Size, height: Size, direction: DirectionMode, ) -> Node

Construct a new Node given a size and a direction

pub fn from_size_and_scroll( width: Size, height: Size, offset_x: Length<f32, Measure>, offset_y: Length<f32, Measure>, ) -> Node

Construct a new Node given a size and a scroll

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

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: DirectionMode, ) -> Node

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: DirectionMode, spacing: Length<f32, Measure>, ) -> Node

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

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

Construct a new Node given a size and a direction

pub fn from_size_and_direction_and_margin( width: Size, height: Size, direction: DirectionMode, margin: Gaps, ) -> Node

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: DirectionMode, padding: Gaps, ) -> Node

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

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

Construct a new Node given a size and a position

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

Construct a new Node given a size and content

pub fn from_size_and_direction_and_spacing( width: Size, height: Size, direction: DirectionMode, spacing: Length<f32, Measure>, ) -> Node

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<(), Error>

Formats the value using the given formatter.

impl Default for Node

fn default() -> Node

Returns the “default value” for a type.

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)

impl StructuralPartialEq for Node