Struct TaffyTree 

pub struct TaffyTree<'a, T, M>
where
    T: TaffyNode,
    T::Context: TaffyConfig,
    M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,
{
    pub composer: &'a mut Composer<T>,
    pub measure_function: M,
}

Fields

composer: &'a mut Composer<T>

measure_function: M

Implementations

impl<'a, T, M> TaffyTree<'a, T, M>

where T: TaffyNode, T::Context: TaffyConfig, M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,

pub fn new(composer: &'a mut Composer<T>, measure_function: M) -> Self

Trait Implementations

impl<T, M> CacheTree for TaffyTree<'_, T, M>

where T: TaffyNode, T::Context: TaffyConfig, M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,

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<T, M> LayoutBlockContainer for TaffyTree<'_, T, M>

where T: TaffyNode, T::Context: TaffyConfig, M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,

type BlockContainerStyle<'a> = <T as TaffyNode>::BlockContainerStyle<'a> where Self: 'a

The style type representing the CSS Block container’s styles

type BlockItemStyle<'a> = <T as TaffyNode>::BlockItemStyle<'a> where Self: 'a

The style type representing each CSS Block item’s styles

fn get_block_container_style( &self, node_id: NodeId, ) -> Self::BlockContainerStyle<'_>

Get the container’s styles

fn get_block_child_style(&self, node_id: NodeId) -> Self::BlockItemStyle<'_>

Get the child’s styles

impl<T, M> LayoutFlexboxContainer for TaffyTree<'_, T, M>

where T: TaffyNode, T::Context: TaffyConfig, M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,

type FlexboxContainerStyle<'a> = <T as TaffyNode>::FlexboxContainerStyle<'a> where Self: 'a

The style type representing the Flexbox container’s styles

type FlexboxItemStyle<'a> = <T as TaffyNode>::FlexboxItemStyle<'a> where Self: 'a

The style type representing each Flexbox item’s styles

fn get_flexbox_container_style( &self, node_id: NodeId, ) -> Self::FlexboxContainerStyle<'_>

Get the container’s styles

fn get_flexbox_child_style(&self, node_id: NodeId) -> Self::FlexboxItemStyle<'_>

Get the child’s styles

impl<T, M> LayoutGridContainer for TaffyTree<'_, T, M>

where T: TaffyNode, T::Context: TaffyConfig, M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,

type GridContainerStyle<'a> = <T as TaffyNode>::GridContainerStyle<'a> where Self: 'a

The style type representing the CSS Grid container’s styles

type GridItemStyle<'a> = <T as TaffyNode>::GridItemStyle<'a> where Self: 'a

The style type representing each CSS Grid item’s styles

fn get_grid_container_style( &self, node_id: NodeId, ) -> Self::GridContainerStyle<'_>

Get the container’s styles

fn get_grid_child_style(&self, node_id: NodeId) -> Self::GridItemStyle<'_>

Get the child’s styles

impl<T, M> LayoutPartialTree for TaffyTree<'_, T, M>

where T: TaffyNode, T::Context: TaffyConfig, M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,

type CoreContainerStyle<'a> = &'a <T as TaffyNode>::CoreContainerStyle where Self: 'a

The style type representing the core container styles that all containers should have Used when laying out the root node of a tree

fn get_core_container_style( &self, node_id: NodeId, ) -> Self::CoreContainerStyle<'_>

Get core style

fn set_unrounded_layout(&mut self, node_id: NodeId, layout: &Layout)

Set the node’s unrounded layout

fn compute_child_layout( &mut self, node_id: NodeId, inputs: LayoutInput, ) -> LayoutOutput

Compute the specified node’s size or full layout given the specified constraints

impl<T, M> PrintTree for TaffyTree<'_, T, M>

where T: TaffyNode, T::Context: TaffyConfig, M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,

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<T, M> RoundTree for TaffyTree<'_, T, M>

where T: TaffyNode, T::Context: TaffyConfig, M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,

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

Get the node’s unrounded layout

fn set_final_layout(&mut self, node_id: NodeId, layout: &Layout)

Get a reference to the node’s final layout

impl<T, M> TraversePartialTree for TaffyTree<'_, T, M>

where T: TaffyNode, T::Context: TaffyConfig, M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,

type ChildIter<'a> = TaffyTreeChildIter<'a> where Self: 'a

Type representing an iterator of the children of a node

fn child_ids(&self, node_id: NodeId) -> Self::ChildIter<'_>

Get the list of children IDs for the given node

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

Get the number of children for the given node

fn get_child_id(&self, node_id: NodeId, child_index: usize) -> NodeId

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

impl<T, M> TraverseTree for TaffyTree<'_, T, M>

where T: TaffyNode, T::Context: TaffyConfig, M: FnMut(Size<Option<f32>>, Size<AvailableSpace>, NodeId, Option<&mut T::NodeContext>, &T::CoreContainerStyle) -> Size<f32>,