Struct taffy::node::Taffy

pub struct Taffy { /* private fields */ }

A tree of UI Nodes, suitable for UI layout

Implementations

impl Taffy

pub fn new() -> Self

Creates a new Taffy

The default capacity of a Taffy is 16 nodes.

pub fn with_capacity(capacity: usize) -> Self

Creates a new Taffy that can store capacity nodes before reallocation

pub fn enable_rounding(&mut self)

Enable rounding of layout values. Rounding is enabled by default.

pub fn disable_rounding(&mut self)

Disable rounding of layout values. Rounding is enabled by default.

pub fn new_leaf(&mut self, layout: Style) -> TaffyResult<Node>

Creates and adds a new unattached leaf node to the tree, and returns the Node of the new node

pub fn new_leaf_with_measure( &mut self, layout: Style, measure: MeasureFunc ) -> TaffyResult<Node>

Creates and adds a new unattached leaf node to the tree, and returns the Node of the new node

Creates and adds a new leaf node with a supplied MeasureFunc

pub fn new_with_children( &mut self, layout: Style, children: &[Node] ) -> TaffyResult<Node>

Creates and adds a new node, which may have any number of children

pub fn clear(&mut self)

Drops all nodes in the tree

pub fn remove(&mut self, node: Node) -> TaffyResult<Node>

Remove a specific Node from the tree and drops it

Returns the id of the node removed.

pub fn set_measure( &mut self, node: Node, measure: Option<MeasureFunc> ) -> TaffyResult<()>

Sets the MeasureFunc of the associated node

pub fn add_child(&mut self, parent: Node, child: Node) -> TaffyResult<()>

Adds a child Node under the supplied parent

pub fn set_children( &mut self, parent: Node, children: &[Node] ) -> TaffyResult<()>

Directly sets the children of the supplied parent

pub fn remove_child(&mut self, parent: Node, child: Node) -> TaffyResult<Node>

Removes the child of the parent node

The child is not removed from the tree entirely, it is simply no longer attached to its previous parent.

pub fn remove_child_at_index( &mut self, parent: Node, child_index: usize ) -> TaffyResult<Node>

Removes the child at the given index from the parent

The child is not removed from the tree entirely, it is simply no longer attached to its previous parent.

pub fn replace_child_at_index( &mut self, parent: Node, child_index: usize, new_child: Node ) -> TaffyResult<Node>

Replaces the child at the given child_index from the parent node with the new child node

The child is not removed from the tree entirely, it is simply no longer attached to its previous parent.

pub fn child_at_index( &self, parent: Node, child_index: usize ) -> TaffyResult<Node>

Returns the child Node of the parent node at the provided child_index

pub fn total_node_count(&self) -> usize

Returns the total number of nodes in the tree

pub fn child_count(&self, parent: Node) -> TaffyResult<usize>

Returns the number of children of the parent Node

pub fn children(&self, parent: Node) -> TaffyResult<Vec<Node>>

Returns a list of children that belong to the parent Node

pub fn set_style(&mut self, node: Node, style: Style) -> TaffyResult<()>

Sets the Style of the provided node

pub fn style(&self, node: Node) -> TaffyResult<&Style>

Gets the Style of the provided node

pub fn layout(&self, node: Node) -> TaffyResult<&Layout>

Return this node layout relative to its parent

pub fn dirty(&self, node: Node) -> TaffyResult<bool>

Indicates whether the layout of this node (and its children) need to be recomputed

pub fn compute_layout( &mut self, node: Node, available_space: Size<AvailableSpace> ) -> Result<(), TaffyError>

Updates the stored layout of the provided node and its children

Trait Implementations

impl Default for Taffy

fn default() -> Self

Returns the “default value” for a type.

impl LayoutTree for Taffy

type ChildIter<'a> = Iter<'a, DefaultKey>

Type representing an iterator of the children of a node

fn children(&self, node: Node) -> Self::ChildIter<'_>

Get the list of children IDs for the given node

fn child_count(&self, node: Node) -> usize

Get the number of children for the given node

fn is_childless(&self, node: Node) -> bool

Returns true if the node has no children

fn parent(&self, node: Node) -> Option<Node>

Get any available parent for this node

fn style(&self, node: Node) -> &Style

Get the Style for this Node.

fn layout(&self, node: Node) -> &Layout

Get the node’s output “Final Layout”

fn layout_mut(&mut self, node: Node) -> &mut Layout

Modify the node’s output layout

fn mark_dirty(&mut self, node: Node) -> TaffyResult<()>

Mark a node as dirty to tell Taffy that something has changed and it needs to be recomputed.

fn measure_node( &self, node: Node, known_dimensions: Size<Option<f32>>, available_space: Size<AvailableSpace> ) -> Size<f32>

Measure a node. Taffy uses this to force reflows of things like text and overflowing content.

fn needs_measure(&self, node: Node) -> bool

Node needs to be measured

fn cache_mut(&mut self, node: Node, index: usize) -> &mut Option<Cache>

Get a cache entry for this Node by index

fn child(&self, node: Node, id: usize) -> Node

Get a specific child of a node, where the index represents the nth child