Enum LayoutTree 

#[non_exhaustive]
pub enum LayoutTree<W> {
    Leaf(W),
    Spacer(LayoutRequest),
    Margin {
        margin: FaceMap<u8>,
        child: Arc<LayoutTree<W>>,
    },
    Stack {
        direction: Face6,
        children: Vec<Arc<LayoutTree<W>>>,
    },
    Shrink(Arc<LayoutTree<W>>),
    Hud {
        crosshair: Arc<LayoutTree<W>>,
        toolbar: Arc<LayoutTree<W>>,
        control_bar: Arc<LayoutTree<W>>,
    },
}

A user interface laid out in 3-dimensional space.

Leaf nodes contain values of type W which describe individual ‘widgets’ (values that implement Layoutable); the tree structure itself describes how they are arranged relative to each other. In this system, widgets do not contain other widgets (at least, not for the purposes of the layout algorithm).

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Leaf(W)

A single widget.

Spacer(LayoutRequest)

An space laid out like a widget but left empty.

Margin

Add the specified amount of space around the child.

Fields

margin: FaceMap<u8>

Minimum amount of space to leave on each face.

child: Arc<LayoutTree<W>>

Stack

Fill the available space with the children arranged along an axis.

Fields

direction: Face6

Which axis of space to arrange on.

children: Vec<Arc<LayoutTree<W>>>

Shrink(Arc<LayoutTree<W>>)

Don’t lay out the contents bigger than minimum.

Hud

A custom layout dedicated to the HUD. TODO: Find a better abstraction than a variant of LayoutTree for this.

Fields

crosshair: Arc<LayoutTree<W>>

toolbar: Arc<LayoutTree<W>>

control_bar: Arc<LayoutTree<W>>

Implementations

impl<W> LayoutTree<W>

pub fn empty() -> Arc<Self>

Constructs a tree node that takes up no space.

pub fn leaf(widget_value: W) -> Arc<Self>

Constructs a LayoutTree::Leaf, already wrapped in Arc.

pub fn spacer(requirements: LayoutRequest) -> Arc<Self>

Constructs a LayoutTree::Spacer, already wrapped in Arc.

pub fn leaves<'s>(&'s self) -> impl Iterator<Item = &'s W> + Clone

Iterates over every leaf (value of type W) in this tree.

impl<W: Layoutable + Clone> LayoutTree<W>

pub fn perform_layout( &self, grant: LayoutGrant, ) -> Result<Arc<LayoutTree<Positioned<W>>>, Infallible>

Given the specified outermost bounds, perform layout and return a tree whose leaves are all Positioned.

TODO: haven’t decided whether layout can fail yet, hence the placeholder non-error

impl LayoutTree<Arc<dyn Widget>>

pub fn to_space<B: Bounds>( self: &Arc<Self>, read_ticket: ReadTicket<'_>, builder: Builder<'_, B>, gravity: Gravity, ) -> Result<Space, InstallVuiError>

Create a Space with these widgets installed in it, just large enough to fit.

Note that the widgets will not actually appear as blocks until the first time the space is stepped.

impl LayoutTree<Positioned<Arc<dyn Widget>>>

pub fn installation( &self, read_ticket: ReadTicket<'_>, ) -> Result<SpaceTransaction, InstallVuiError>

Creates a transaction which will install all of the widgets in this tree.

The provided read_ticket should be for the universe the transaction will be executed in.

Returns an error if the widgets conflict with each other.

Trait Implementations

impl<W: Clone> Clone for LayoutTree<W>

fn clone(&self) -> LayoutTree<W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<W: Debug> Debug for LayoutTree<W>

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

Formats the value using the given formatter.

impl<W: Layoutable> Layoutable for LayoutTree<W>

fn requirements(&self) -> LayoutRequest

Requested minimum size and positioning of this object.

impl<W: PartialEq> PartialEq for LayoutTree<W>

fn eq(&self, other: &LayoutTree<W>) -> 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<W: Eq> Eq for LayoutTree<W>

impl<W> StructuralPartialEq for LayoutTree<W>