Struct TaffyTree 

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

Available on crate feature taffy_tree only.

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() -> Self

Creates a new TaffyTree

The default capacity of a TaffyTree is 16 nodes.

Examples found in repository

examples/flexbox_gap.rs (line 7)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child_style = Style { size: Size { width: length(20.0), height: length(20.0) }, ..Default::default() };
    let child0 = taffy.new_leaf(child_style.clone())?;
    let child1 = taffy.new_leaf(child_style.clone())?;
    let child2 = taffy.new_leaf(child_style.clone())?;

    let root = taffy.new_with_children(
        Style { gap: Size { width: length(10.0), height: zero() }, ..Default::default() },
        &[child0, child1, child2],
    )?;

    // Compute layout and print result
    taffy.compute_layout(root, Size::MAX_CONTENT)?;
    taffy.print_tree(root);

    Ok(())
}

examples/basic.rs (line 4)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_percent(0.5), height: Dimension::AUTO },
        ..Default::default()
    })?;

    let node = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_length(100.0), height: Dimension::from_length(100.0) },
            justify_content: Some(JustifyContent::CENTER),
            ..Default::default()
        },
        &[child],
    )?;

    println!("Compute layout with 100x100 viewport:");
    taffy.compute_layout(
        node,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    println!("Compute layout with undefined (infinite) viewport:");
    taffy.compute_layout(node, Size::MAX_CONTENT)?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    Ok(())
}

examples/grid_holy_grail.rs (line 22)

fn main() -> Result<(), taffy::TaffyError> {
    use taffy::prelude::*;

    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // Setup the grid
    let root_style = Style {
        display: Display::Grid,
        size: Size { width: length(800.0), height: length(600.0) },
        grid_template_columns: vec![length(250.0), fr(1.0), length(250.0)],
        grid_template_rows: vec![length(150.0), fr(1.0), length(150.0)],
        ..default()
    };

    // Define the child nodes
    let header = taffy.new_leaf(Style { grid_row: line(1), grid_column: span(3), ..default() })?;
    let left_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(1), ..default() })?;
    let content_area = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(2), ..default() })?;
    let right_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(3), ..default() })?;
    let footer = taffy.new_leaf(Style { grid_row: line(3), grid_column: span(3), ..default() })?;

    // Create the container with the children
    let root = taffy.new_with_children(root_style, &[header, left_sidebar, content_area, right_sidebar, footer])?;

    // Compute layout and print result
    taffy.compute_layout(root, Size { width: length(800.0), height: length(600.0) })?;
    taffy.print_tree(root);

    Ok(())
}

examples/measure.rs (line 34)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<NodeContext> = TaffyTree::new();

    let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };

    let text_node = taffy.new_leaf_with_context(
        Style::default(),
        NodeContext::Text(TextContext { text_content: LOREM_IPSUM.into(), writing_mode: WritingMode::Horizontal }),
    )?;

    let image_node = taffy
        .new_leaf_with_context(Style::default(), NodeContext::Image(ImageContext { width: 400.0, height: 300.0 }))?;

    let root = taffy.new_with_children(
        Style {
            display: Display::Flex,
            flex_direction: FlexDirection::Column,
            size: Size { width: length(200.0), height: auto() },
            ..Default::default()
        },
        &[text_node, image_node],
    )?;

    // Compute layout and print result
    taffy.compute_layout_with_measure(
        root,
        Size::MAX_CONTENT,
        // Note: this closure is a FnMut closure and can be used to borrow external context for the duration of layout
        // For example, you may wish to borrow a global font registry and pass it into your text measuring function
        |known_dimensions, available_space, _node_id, node_context, _style| {
            measure_function(known_dimensions, available_space, node_context, &font_metrics)
        },
    )?;
    taffy.print_tree(root);

    Ok(())
}

examples/nested.rs (line 4)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // left
    let child_t1 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div1 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t1],
    )?;

    // right
    let child_t2 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div2 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t2],
    )?;

    let container = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(1.0), height: Dimension::from_percent(1.0) },
            ..Default::default()
        },
        &[div1, div2],
    )?;

    taffy.compute_layout(
        container,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;

    println!("node: {:#?}", taffy.layout(container)?);

    println!("div1: {:#?}", taffy.layout(div1)?);
    println!("div2: {:#?}", taffy.layout(div2)?);

    println!("child1: {:#?}", taffy.layout(child_t1)?);
    println!("child2: {:#?}", taffy.layout(child_t2)?);

    Ok(())
}

pub fn with_capacity(capacity: usize) -> Self

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) -> TaffyResult<NodeId>

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

Examples found in repository

examples/flexbox_gap.rs (line 10)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child_style = Style { size: Size { width: length(20.0), height: length(20.0) }, ..Default::default() };
    let child0 = taffy.new_leaf(child_style.clone())?;
    let child1 = taffy.new_leaf(child_style.clone())?;
    let child2 = taffy.new_leaf(child_style.clone())?;

    let root = taffy.new_with_children(
        Style { gap: Size { width: length(10.0), height: zero() }, ..Default::default() },
        &[child0, child1, child2],
    )?;

    // Compute layout and print result
    taffy.compute_layout(root, Size::MAX_CONTENT)?;
    taffy.print_tree(root);

    Ok(())
}

examples/basic.rs (lines 6-9)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_percent(0.5), height: Dimension::AUTO },
        ..Default::default()
    })?;

    let node = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_length(100.0), height: Dimension::from_length(100.0) },
            justify_content: Some(JustifyContent::CENTER),
            ..Default::default()
        },
        &[child],
    )?;

    println!("Compute layout with 100x100 viewport:");
    taffy.compute_layout(
        node,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    println!("Compute layout with undefined (infinite) viewport:");
    taffy.compute_layout(node, Size::MAX_CONTENT)?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    Ok(())
}

examples/grid_holy_grail.rs (line 34)

fn main() -> Result<(), taffy::TaffyError> {
    use taffy::prelude::*;

    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // Setup the grid
    let root_style = Style {
        display: Display::Grid,
        size: Size { width: length(800.0), height: length(600.0) },
        grid_template_columns: vec![length(250.0), fr(1.0), length(250.0)],
        grid_template_rows: vec![length(150.0), fr(1.0), length(150.0)],
        ..default()
    };

    // Define the child nodes
    let header = taffy.new_leaf(Style { grid_row: line(1), grid_column: span(3), ..default() })?;
    let left_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(1), ..default() })?;
    let content_area = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(2), ..default() })?;
    let right_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(3), ..default() })?;
    let footer = taffy.new_leaf(Style { grid_row: line(3), grid_column: span(3), ..default() })?;

    // Create the container with the children
    let root = taffy.new_with_children(root_style, &[header, left_sidebar, content_area, right_sidebar, footer])?;

    // Compute layout and print result
    taffy.compute_layout(root, Size { width: length(800.0), height: length(600.0) })?;
    taffy.print_tree(root);

    Ok(())
}

examples/nested.rs (lines 7-10)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // left
    let child_t1 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div1 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t1],
    )?;

    // right
    let child_t2 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div2 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t2],
    )?;

    let container = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(1.0), height: Dimension::from_percent(1.0) },
            ..Default::default()
        },
        &[div1, div2],
    )?;

    taffy.compute_layout(
        container,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;

    println!("node: {:#?}", taffy.layout(container)?);

    println!("div1: {:#?}", taffy.layout(div1)?);
    println!("div2: {:#?}", taffy.layout(div2)?);

    println!("child1: {:#?}", taffy.layout(child_t1)?);
    println!("child2: {:#?}", taffy.layout(child_t2)?);

    Ok(())
}

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

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

Examples found in repository

examples/measure.rs (lines 38-41)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<NodeContext> = TaffyTree::new();

    let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };

    let text_node = taffy.new_leaf_with_context(
        Style::default(),
        NodeContext::Text(TextContext { text_content: LOREM_IPSUM.into(), writing_mode: WritingMode::Horizontal }),
    )?;

    let image_node = taffy
        .new_leaf_with_context(Style::default(), NodeContext::Image(ImageContext { width: 400.0, height: 300.0 }))?;

    let root = taffy.new_with_children(
        Style {
            display: Display::Flex,
            flex_direction: FlexDirection::Column,
            size: Size { width: length(200.0), height: auto() },
            ..Default::default()
        },
        &[text_node, image_node],
    )?;

    // Compute layout and print result
    taffy.compute_layout_with_measure(
        root,
        Size::MAX_CONTENT,
        // Note: this closure is a FnMut closure and can be used to borrow external context for the duration of layout
        // For example, you may wish to borrow a global font registry and pass it into your text measuring function
        |known_dimensions, available_space, _node_id, node_context, _style| {
            measure_function(known_dimensions, available_space, node_context, &font_metrics)
        },
    )?;
    taffy.print_tree(root);

    Ok(())
}

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

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

Examples found in repository

examples/flexbox_gap.rs (lines 14-17)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child_style = Style { size: Size { width: length(20.0), height: length(20.0) }, ..Default::default() };
    let child0 = taffy.new_leaf(child_style.clone())?;
    let child1 = taffy.new_leaf(child_style.clone())?;
    let child2 = taffy.new_leaf(child_style.clone())?;

    let root = taffy.new_with_children(
        Style { gap: Size { width: length(10.0), height: zero() }, ..Default::default() },
        &[child0, child1, child2],
    )?;

    // Compute layout and print result
    taffy.compute_layout(root, Size::MAX_CONTENT)?;
    taffy.print_tree(root);

    Ok(())
}

examples/basic.rs (lines 11-18)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_percent(0.5), height: Dimension::AUTO },
        ..Default::default()
    })?;

    let node = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_length(100.0), height: Dimension::from_length(100.0) },
            justify_content: Some(JustifyContent::CENTER),
            ..Default::default()
        },
        &[child],
    )?;

    println!("Compute layout with 100x100 viewport:");
    taffy.compute_layout(
        node,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    println!("Compute layout with undefined (infinite) viewport:");
    taffy.compute_layout(node, Size::MAX_CONTENT)?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    Ok(())
}

examples/grid_holy_grail.rs (line 41)

fn main() -> Result<(), taffy::TaffyError> {
    use taffy::prelude::*;

    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // Setup the grid
    let root_style = Style {
        display: Display::Grid,
        size: Size { width: length(800.0), height: length(600.0) },
        grid_template_columns: vec![length(250.0), fr(1.0), length(250.0)],
        grid_template_rows: vec![length(150.0), fr(1.0), length(150.0)],
        ..default()
    };

    // Define the child nodes
    let header = taffy.new_leaf(Style { grid_row: line(1), grid_column: span(3), ..default() })?;
    let left_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(1), ..default() })?;
    let content_area = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(2), ..default() })?;
    let right_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(3), ..default() })?;
    let footer = taffy.new_leaf(Style { grid_row: line(3), grid_column: span(3), ..default() })?;

    // Create the container with the children
    let root = taffy.new_with_children(root_style, &[header, left_sidebar, content_area, right_sidebar, footer])?;

    // Compute layout and print result
    taffy.compute_layout(root, Size { width: length(800.0), height: length(600.0) })?;
    taffy.print_tree(root);

    Ok(())
}

examples/measure.rs (lines 46-54)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<NodeContext> = TaffyTree::new();

    let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };

    let text_node = taffy.new_leaf_with_context(
        Style::default(),
        NodeContext::Text(TextContext { text_content: LOREM_IPSUM.into(), writing_mode: WritingMode::Horizontal }),
    )?;

    let image_node = taffy
        .new_leaf_with_context(Style::default(), NodeContext::Image(ImageContext { width: 400.0, height: 300.0 }))?;

    let root = taffy.new_with_children(
        Style {
            display: Display::Flex,
            flex_direction: FlexDirection::Column,
            size: Size { width: length(200.0), height: auto() },
            ..Default::default()
        },
        &[text_node, image_node],
    )?;

    // Compute layout and print result
    taffy.compute_layout_with_measure(
        root,
        Size::MAX_CONTENT,
        // Note: this closure is a FnMut closure and can be used to borrow external context for the duration of layout
        // For example, you may wish to borrow a global font registry and pass it into your text measuring function
        |known_dimensions, available_space, _node_id, node_context, _style| {
            measure_function(known_dimensions, available_space, node_context, &font_metrics)
        },
    )?;
    taffy.print_tree(root);

    Ok(())
}

examples/nested.rs (lines 12-19)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // left
    let child_t1 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div1 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t1],
    )?;

    // right
    let child_t2 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div2 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t2],
    )?;

    let container = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(1.0), height: Dimension::from_percent(1.0) },
            ..Default::default()
        },
        &[div1, div2],
    )?;

    taffy.compute_layout(
        container,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;

    println!("node: {:#?}", taffy.layout(container)?);

    println!("div1: {:#?}", taffy.layout(div1)?);
    println!("div2: {:#?}", taffy.layout(div2)?);

    println!("child1: {:#?}", taffy.layout(child_t1)?);
    println!("child2: {:#?}", taffy.layout(child_t2)?);

    Ok(())
}

pub fn clear(&mut self)

Drops all nodes in the tree

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

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

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) -> TaffyResult<()>

Adds a child node under the supplied parent

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

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], ) -> TaffyResult<()>

Directly sets the children of the supplied parent

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

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, ) -> TaffyResult<NodeId>

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

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, ) -> TaffyResult<NodeId>

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, ) -> TaffyResult<NodeId>

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) -> TaffyResult<Vec<NodeId>>

Returns a list of children that belong to the parent node

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

Sets the Style of the provided node

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

Gets the Style of the provided node

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

Return this node layout relative to its parent

Examples found in repository

examples/basic.rs (line 25)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_percent(0.5), height: Dimension::AUTO },
        ..Default::default()
    })?;

    let node = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_length(100.0), height: Dimension::from_length(100.0) },
            justify_content: Some(JustifyContent::CENTER),
            ..Default::default()
        },
        &[child],
    )?;

    println!("Compute layout with 100x100 viewport:");
    taffy.compute_layout(
        node,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    println!("Compute layout with undefined (infinite) viewport:");
    taffy.compute_layout(node, Size::MAX_CONTENT)?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    Ok(())
}

examples/nested.rs (line 49)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // left
    let child_t1 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div1 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t1],
    )?;

    // right
    let child_t2 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div2 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t2],
    )?;

    let container = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(1.0), height: Dimension::from_percent(1.0) },
            ..Default::default()
        },
        &[div1, div2],
    )?;

    taffy.compute_layout(
        container,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;

    println!("node: {:#?}", taffy.layout(container)?);

    println!("div1: {:#?}", taffy.layout(div1)?);
    println!("div2: {:#?}", taffy.layout(div2)?);

    println!("child1: {:#?}", taffy.layout(child_t1)?);
    println!("child2: {:#?}", taffy.layout(child_t2)?);

    Ok(())
}

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

Available on crate feature detailed_layout_info only.

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) -> TaffyResult<()>

Marks the layout of this node and its ancestors as outdated

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

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

Examples found in repository

examples/measure.rs (lines 57-65)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<NodeContext> = TaffyTree::new();

    let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };

    let text_node = taffy.new_leaf_with_context(
        Style::default(),
        NodeContext::Text(TextContext { text_content: LOREM_IPSUM.into(), writing_mode: WritingMode::Horizontal }),
    )?;

    let image_node = taffy
        .new_leaf_with_context(Style::default(), NodeContext::Image(ImageContext { width: 400.0, height: 300.0 }))?;

    let root = taffy.new_with_children(
        Style {
            display: Display::Flex,
            flex_direction: FlexDirection::Column,
            size: Size { width: length(200.0), height: auto() },
            ..Default::default()
        },
        &[text_node, image_node],
    )?;

    // Compute layout and print result
    taffy.compute_layout_with_measure(
        root,
        Size::MAX_CONTENT,
        // Note: this closure is a FnMut closure and can be used to borrow external context for the duration of layout
        // For example, you may wish to borrow a global font registry and pass it into your text measuring function
        |known_dimensions, available_space, _node_id, node_context, _style| {
            measure_function(known_dimensions, available_space, node_context, &font_metrics)
        },
    )?;
    taffy.print_tree(root);

    Ok(())
}

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

Examples found in repository

examples/flexbox_gap.rs (line 20)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child_style = Style { size: Size { width: length(20.0), height: length(20.0) }, ..Default::default() };
    let child0 = taffy.new_leaf(child_style.clone())?;
    let child1 = taffy.new_leaf(child_style.clone())?;
    let child2 = taffy.new_leaf(child_style.clone())?;

    let root = taffy.new_with_children(
        Style { gap: Size { width: length(10.0), height: zero() }, ..Default::default() },
        &[child0, child1, child2],
    )?;

    // Compute layout and print result
    taffy.compute_layout(root, Size::MAX_CONTENT)?;
    taffy.print_tree(root);

    Ok(())
}

examples/basic.rs (lines 21-24)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_percent(0.5), height: Dimension::AUTO },
        ..Default::default()
    })?;

    let node = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_length(100.0), height: Dimension::from_length(100.0) },
            justify_content: Some(JustifyContent::CENTER),
            ..Default::default()
        },
        &[child],
    )?;

    println!("Compute layout with 100x100 viewport:");
    taffy.compute_layout(
        node,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    println!("Compute layout with undefined (infinite) viewport:");
    taffy.compute_layout(node, Size::MAX_CONTENT)?;
    println!("node: {:#?}", taffy.layout(node)?);
    println!("child: {:#?}", taffy.layout(child)?);

    Ok(())
}

examples/grid_holy_grail.rs (line 44)

fn main() -> Result<(), taffy::TaffyError> {
    use taffy::prelude::*;

    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // Setup the grid
    let root_style = Style {
        display: Display::Grid,
        size: Size { width: length(800.0), height: length(600.0) },
        grid_template_columns: vec![length(250.0), fr(1.0), length(250.0)],
        grid_template_rows: vec![length(150.0), fr(1.0), length(150.0)],
        ..default()
    };

    // Define the child nodes
    let header = taffy.new_leaf(Style { grid_row: line(1), grid_column: span(3), ..default() })?;
    let left_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(1), ..default() })?;
    let content_area = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(2), ..default() })?;
    let right_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(3), ..default() })?;
    let footer = taffy.new_leaf(Style { grid_row: line(3), grid_column: span(3), ..default() })?;

    // Create the container with the children
    let root = taffy.new_with_children(root_style, &[header, left_sidebar, content_area, right_sidebar, footer])?;

    // Compute layout and print result
    taffy.compute_layout(root, Size { width: length(800.0), height: length(600.0) })?;
    taffy.print_tree(root);

    Ok(())
}

examples/nested.rs (lines 44-47)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // left
    let child_t1 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div1 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t1],
    )?;

    // right
    let child_t2 = taffy.new_leaf(Style {
        size: Size { width: Dimension::from_length(5.0), height: Dimension::from_length(5.0) },
        ..Default::default()
    })?;

    let div2 = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(0.5), height: Dimension::from_percent(1.0) },
            // justify_content: JustifyContent::Center,
            ..Default::default()
        },
        &[child_t2],
    )?;

    let container = taffy.new_with_children(
        Style {
            size: Size { width: Dimension::from_percent(1.0), height: Dimension::from_percent(1.0) },
            ..Default::default()
        },
        &[div1, div2],
    )?;

    taffy.compute_layout(
        container,
        Size { height: AvailableSpace::Definite(100.0), width: AvailableSpace::Definite(100.0) },
    )?;

    println!("node: {:#?}", taffy.layout(container)?);

    println!("div1: {:#?}", taffy.layout(div1)?);
    println!("div2: {:#?}", taffy.layout(div2)?);

    println!("child1: {:#?}", taffy.layout(child_t1)?);
    println!("child2: {:#?}", taffy.layout(child_t2)?);

    Ok(())
}

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

Available on crate feature std only.

Prints a debug representation of the tree’s layout

Examples found in repository

examples/flexbox_gap.rs (line 21)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<()> = TaffyTree::new();

    let child_style = Style { size: Size { width: length(20.0), height: length(20.0) }, ..Default::default() };
    let child0 = taffy.new_leaf(child_style.clone())?;
    let child1 = taffy.new_leaf(child_style.clone())?;
    let child2 = taffy.new_leaf(child_style.clone())?;

    let root = taffy.new_with_children(
        Style { gap: Size { width: length(10.0), height: zero() }, ..Default::default() },
        &[child0, child1, child2],
    )?;

    // Compute layout and print result
    taffy.compute_layout(root, Size::MAX_CONTENT)?;
    taffy.print_tree(root);

    Ok(())
}

examples/grid_holy_grail.rs (line 45)

fn main() -> Result<(), taffy::TaffyError> {
    use taffy::prelude::*;

    let mut taffy: TaffyTree<()> = TaffyTree::new();

    // Setup the grid
    let root_style = Style {
        display: Display::Grid,
        size: Size { width: length(800.0), height: length(600.0) },
        grid_template_columns: vec![length(250.0), fr(1.0), length(250.0)],
        grid_template_rows: vec![length(150.0), fr(1.0), length(150.0)],
        ..default()
    };

    // Define the child nodes
    let header = taffy.new_leaf(Style { grid_row: line(1), grid_column: span(3), ..default() })?;
    let left_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(1), ..default() })?;
    let content_area = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(2), ..default() })?;
    let right_sidebar = taffy.new_leaf(Style { grid_row: line(2), grid_column: line(3), ..default() })?;
    let footer = taffy.new_leaf(Style { grid_row: line(3), grid_column: span(3), ..default() })?;

    // Create the container with the children
    let root = taffy.new_with_children(root_style, &[header, left_sidebar, content_area, right_sidebar, footer])?;

    // Compute layout and print result
    taffy.compute_layout(root, Size { width: length(800.0), height: length(600.0) })?;
    taffy.print_tree(root);

    Ok(())
}

examples/measure.rs (line 66)

fn main() -> Result<(), taffy::TaffyError> {
    let mut taffy: TaffyTree<NodeContext> = TaffyTree::new();

    let font_metrics = FontMetrics { char_width: 10.0, char_height: 10.0 };

    let text_node = taffy.new_leaf_with_context(
        Style::default(),
        NodeContext::Text(TextContext { text_content: LOREM_IPSUM.into(), writing_mode: WritingMode::Horizontal }),
    )?;

    let image_node = taffy
        .new_leaf_with_context(Style::default(), NodeContext::Image(ImageContext { width: 400.0, height: 300.0 }))?;

    let root = taffy.new_with_children(
        Style {
            display: Display::Flex,
            flex_direction: FlexDirection::Column,
            size: Size { width: length(200.0), height: auto() },
            ..Default::default()
        },
        &[text_node, image_node],
    )?;

    // Compute layout and print result
    taffy.compute_layout_with_measure(
        root,
        Size::MAX_CONTENT,
        // Note: this closure is a FnMut closure and can be used to borrow external context for the duration of layout
        // For example, you may wish to borrow a global font registry and pass it into your text measuring function
        |known_dimensions, available_space, _node_id, node_context, _style| {
            measure_function(known_dimensions, available_space, node_context, &font_metrics)
        },
    )?;
    taffy.print_tree(root);

    Ok(())
}

Trait Implementations

impl<NodeContext> CacheTree for TaffyTree<NodeContext>

fn cache_get( &self, node_id: NodeId, input: &LayoutInput, ) -> Option<LayoutOutput>

Try to retrieve a cached result from the cache

fn cache_store( &mut self, node_id: NodeId, input: &LayoutInput, 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> Clone for TaffyTree<NodeContext>

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> Debug for TaffyTree<NodeContext>

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

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 Self: 'a

Type representing an iterator of the children of a node

fn child_ids(&self, parent_node_id: NodeId) -> Self::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>