Struct TaffyTree 

pub struct TaffyTree<NodeContext = ()> { /* private fields */ }

An entire tree of UI nodes. The entry point to Taffy’s high-level API.

Allows you to build a tree of UI nodes, run Taffy’s layout algorithms over that tree, and then access the resultant layout.]

Implementations

impl<NodeContext> TaffyTree<NodeContext>

pub fn new() -> TaffyTree<NodeContext>

Creates a new TaffyTree

The default capacity of a TaffyTree is 16 nodes.

pub fn with_capacity(capacity: usize) -> TaffyTree<NodeContext>

Creates a new TaffyTree 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) -> Result<NodeId, TaffyError>

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

pub fn new_leaf_with_context( &mut self, layout: Style, context: NodeContext, ) -> Result<NodeId, TaffyError>

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

Creates and adds a new leaf node with a supplied context

pub fn new_with_children( &mut self, layout: Style, children: &[NodeId], ) -> Result<NodeId, TaffyError>

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: NodeId) -> Result<NodeId, TaffyError>

Remove a specific node from the tree and drop it

Returns the id of the node removed.

pub fn set_node_context( &mut self, node: NodeId, measure: Option<NodeContext>, ) -> Result<(), TaffyError>

Sets the context data associated with the node

pub fn get_node_context(&self, node: NodeId) -> Option<&NodeContext>

Gets a reference to the the context data associated with the node

pub fn get_node_context_mut(&mut self, node: NodeId) -> Option<&mut NodeContext>

Gets a mutable reference to the the context data associated with the node

pub fn get_disjoint_node_context_mut<const N: usize>( &mut self, keys: [NodeId; N], ) -> Option<[&mut NodeContext; N]>

Gets mutable references to the the context data associated with the nodes. All keys must be valid and disjoint, otherwise None is returned.

pub fn add_child( &mut self, parent: NodeId, child: NodeId, ) -> Result<(), TaffyError>

Adds a child node under the supplied parent

pub fn insert_child_at_index( &mut self, parent: NodeId, child_index: usize, child: NodeId, ) -> Result<(), TaffyError>

Inserts a child node at the given child_index under the supplied parent, shifting all children after it to the right.

pub fn set_children( &mut self, parent: NodeId, children: &[NodeId], ) -> Result<(), TaffyError>

Directly sets the children of the supplied parent

pub fn remove_child( &mut self, parent: NodeId, child: NodeId, ) -> Result<NodeId, TaffyError>

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: NodeId, child_index: usize, ) -> Result<NodeId, TaffyError>

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 remove_children_range<R>( &mut self, parent: NodeId, range: R, ) -> Result<(), TaffyError>

where R: RangeBounds<usize>,

Removes children at the given range from the parent

Children are not removed from the tree entirely, they are simply no longer attached to their previous parent.

Function will panic if given range is invalid. See core::slice::range

pub fn replace_child_at_index( &mut self, parent: NodeId, child_index: usize, new_child: NodeId, ) -> Result<NodeId, TaffyError>

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: NodeId, child_index: usize, ) -> Result<NodeId, TaffyError>

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 parent(&self, child_id: NodeId) -> Option<NodeId>

Returns the NodeId of the parent node of the specified node (if it exists)

• Return None if the specified node has no parent
• Panics if the specified node does not exist

pub fn children(&self, parent: NodeId) -> Result<Vec<NodeId>, TaffyError>

Returns a list of children that belong to the parent node

pub fn set_style( &mut self, node: NodeId, style: Style, ) -> Result<(), TaffyError>

Sets the Style of the provided node

pub fn style(&self, node: NodeId) -> Result<&Style, TaffyError>

Gets the Style of the provided node

pub fn layout(&self, node: NodeId) -> Result<&Layout, TaffyError>

Return this node layout relative to its parent

pub fn unrounded_layout(&self, node: NodeId) -> &Layout

Returns this node layout with unrounded values relative to its parent.

pub fn detailed_layout_info(&self, node_id: NodeId) -> &DetailedLayoutInfo

Get the “detailed layout info” for a node.

Currently this is only implemented for CSS Grid containers where it contains the computed size of each grid track and the computed placement of each grid item

pub fn mark_dirty(&mut self, node: NodeId) -> Result<(), TaffyError>

Marks the layout of this node and its ancestors as outdated

pub fn dirty(&self, node: NodeId) -> Result<bool, TaffyError>

Indicates whether the layout of this node needs to be recomputed

pub fn compute_layout_with_measure<MeasureFunction>( &mut self, node_id: NodeId, available_space: Size<AvailableSpace>, measure_function: MeasureFunction, ) -> Result<(), TaffyError>

where MeasureFunction: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut NodeContext>, &Style) -> Size<f32>,

Updates the stored layout of the provided node and its children

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

Updates the stored layout of the provided node and its children

pub fn print_tree(&mut self, root: NodeId)

Prints a debug representation of the tree’s layout

Trait Implementations

impl<NodeContext> CacheTree for TaffyTree<NodeContext>

fn cache_get( &self, node_id: NodeId, known_dimensions: Size<Option<f32>>, available_space: Size<AvailableSpace>, run_mode: RunMode, ) -> Option<LayoutOutput>

Try to retrieve a cached result from the cache

fn cache_store( &mut self, node_id: NodeId, known_dimensions: Size<Option<f32>>, available_space: Size<AvailableSpace>, run_mode: RunMode, layout_output: LayoutOutput, )

Store a computed size in the cache

fn cache_clear(&mut self, node_id: NodeId)

Clear all cache entries for the node

impl<NodeContext> Clone for TaffyTree<NodeContext>

where NodeContext: Clone,

fn clone(&self) -> TaffyTree<NodeContext>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<NodeContext> Debug for TaffyTree<NodeContext>

where NodeContext: Debug,

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

Formats the value using the given formatter.

impl Default for TaffyTree

fn default() -> TaffyTree

Returns the “default value” for a type.

impl<NodeContext> PrintTree for TaffyTree<NodeContext>

fn get_debug_label(&self, node_id: NodeId) -> &'static str

Get a debug label for the node (typically the type of node: flexbox, grid, text, image, etc)

fn get_final_layout(&self, node_id: NodeId) -> Layout

Get a reference to the node’s final layout

impl<NodeContext> TraversePartialTree for TaffyTree<NodeContext>

type ChildIter<'a> = TaffyTreeChildIter<'a> where TaffyTree<NodeContext>: 'a

Type representing an iterator of the children of a node

fn child_ids( &self, parent_node_id: NodeId, ) -> <TaffyTree<NodeContext> as TraversePartialTree>::ChildIter<'_>

Get the list of children IDs for the given node

fn child_count(&self, parent_node_id: NodeId) -> usize

Get the number of children for the given node

fn get_child_id(&self, parent_node_id: NodeId, id: usize) -> NodeId

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

impl<NodeContext> TraverseTree for TaffyTree<NodeContext>