v0.4.0

Highlights

• Support for CSS Block layout (display: block)
• Support for the overflow property (+ scrollbar_width for overflow: scroll)
• Improved measure function API
• Completely refactored low-level API
• Simplified module hierarchy (+ most types/functions are now exported from the crate root)
• Expanded set of examples which better document integration with other layout systems (e.g. text layout)
• Computed values for padding and border are now output into the Layout struct

Block layout

Support for CSS Block layout has been added. This can be used via the new Display::Block variant of the Display enum. Note that full flow layout: inline, inline-block and float layout have not been implemented. The use case supported is block container nodes which contain block-level children.

Overflow property

Support has been added for a new overflow style property with Visible, Clip, Hidden, and Scroll values (Auto is not currently implemented). Additionally a scrollbar_width property has been added to control the size of scrollbars for nodes with Overflow::Scroll set.

• Overflow is settable indpendently in each axis.
• Visible and Clip will produce layouts equivalent to the Taffy 0.3. Clip will affect the new content_size output by restricting it to the available space.
• Hidden and Scroll affect layout by changing the automatic minimum size of Flexbox and Grid children
• Scroll additionally reserves scrollbar_width pixels for a scrollbar in the opposite axis to which scrolling is enabled. Scroll with scrollbar_width set to zero is equivalent to Hidden.

Measure function changes

The "measure function" API for integrating Taffy with other measurement systems (such as text layout) has been changed to be more flexible
and to interact better with borrow checking (you can now borrow external data in your measure function!).

• There are no longer per-node measure functions.
• There is now a single "global" measure function, and a per-node "context" of a user-defined type
• The Taffy tree is now a generic TaffyTree<T> where T is the "context" type.
• The measure function is now called for all leaf nodes (nodes without children). If you wish to maintain compatibility with the previous
  behaviour then your measure function should return Size::ZERO for leaf nodes whose context is None.

If you are not using measure functions, then the only change you will need to make is from:

let mut tree = Taffy::new();

to

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

And generally update any uses of Taffy in your codebase to TaffyTree<()>.

If you are using measure functions then you will need to make some bigger (but straightforward) changes. The following Taffy 0.3 code:

let mut tree = Taffy::new();
let leaf = tree.new_leaf_with_measure(
  Style::DEFAULT,
  |known_dimensions: Size<Option<f32>>, available_space: Size<AvailableSpace>| Size { width: 100.0, height: 200.0 }
);
tree.compute_layout(leaf, Size::MAX_CONTENT);

Should become something like the following with Taffy 0.4:

let mut tree : TaffyTree<Size> = TaffyTree::new();
let leaf = tree.new_leaf_with_context(Style::DEFAULT, Size { width: 100.0, height: 200.0 });
tree.compute_layout_with_measure(
  leaf,
  Size::MAX_CONTENT,
  |known_dimensions: Size<Option<f32>>, available_space: Size<AvailableSpace>, node_id: NodeId, node_context: Option<Size>| {
    node_context.unwrap_or(Size::ZERO)
  }
);

Note that:

• You can choose any type instead of Size in the above example. This includes your own custom type (which can be an enum or a trait object).
• If you don't need a context then you can use () for the context type
• As the single "global" measure function passed to compute_layout_with_measure only needs to exist for the duration of a single layout run,
  it can (mutably) borrow data from it's environment

Low-level API (LayoutTree trait) refactor

The low-level API has been completely reworked:

• The LayoutTree trait has been split into 5 smaller traits which live in the taffy::tree:traits module (along with their associated documentation)
• The following methods have been removed from split LayoutTree traits entirely: parent, is_childless, measure_node, needs_measure, and mark_dirty.
• taffy::node::Node has been replaced with taffy::NodeId. This should make it much easier to implement the low-level traits as the underlying type backing the node id now a u64 rather than a slotmap::DefaultKey.
• Support for running each layout algorithm individually on a single node via the following top-level functions:
  • compute_flexbox_layout
  • compute_grid_layout
  • compute_block_layout
  • compute_leaf_layout
  • compute_root_layout
  • compute_hidden_layout

It is believed that nobody was previously using the low-level API so we are not providing a migration guide. However, along with the refactor we have greatly
improved both the documentation and have added examples using the new API, both of which are linked to from the main documentation page.

Module hierarchy changes

The specific changes are detailed below. However for most users the most significant change will be that almost all types are now re-exported from the root module. This means that module specific imports like use taffy::layout::Layout can now in almost all cases be replaced with the simpler use taffy::Layout.

Specific changes:

• The math module has been made private
• The axis module has been merged into the geometry module
• The debug module is no longer public. The print_tree function is now accessible under util.
• All types from the node, data, layout, error and cache modules have been moved to the the tree module.
• The layout_flexbox() function has been removed from the prelude. Use taffy::compute_flexbox_layout instead.

Many APIs have been renamed to replace points or Points with length or Length

This new name better describes one-dimensional measure of space in some unspecified unit
which is often unrelated to the PostScript point or the CSS pt unit.

This also removes a misleading similarity with the 2D Point,
whose components can have any unit and are not even necessarily absolute lengths.

Example usage change:

 use taffy::prelude::*;

 // …

 let header_node = taffy
     .new_leaf(
         Style {
-            size: Size { width: points(800.0), height: points(100.0) },
+            size: Size { width: length(800.0), height: length(100.0) },
             ..Default::default()
         },
     ).unwrap();

Other Changes

• The Taffy type was renamed to TaffyTree and made generic of a context parameter
• The Flexbox algorithm has now been moved behind the flexbox feature. The flexbox feature is enabled by default.
• The justify_self property has been moved behind the grid feature.
• Fixed misspelling: RunMode::PeformLayout renamed into RunMode::PerformLayout (added missing r).
• serde dependency has been made compatible with no_std environments
• slotmap dependency has been made compatible with no_std environments
• Added insert_child_at_index() method to the TaffyTree. This can be used to insert a child node at any position instead of just the end.
• Added total_node_count() method to the TaffyTree which returns the total number of nodes in the tree.
• Added get_disjoint_node_context_mut() method to the TaffyTree. This can be used to safely get multiple mutable borrows at the same time.

v0.3.18

Fixes

• Fix computation of Flexbox automatic minimum size when grid or flexbox child has an explicit width/height style set (#576)

v0.3.17

Added

• Added total_node_count method to the Taffy struct. Returns the total number of nodes in the tree.

Fixes

• Flexbox: fix O(n^2) order lookup (#537). Greatly improves layout performance on wide trees.

v0.3.16

Fixes

• Improve flexbox column performance (#557)

v0.3.15

Fixes

• Fix justify-content and align-content when free space is negative (content overflows container) (#549) (#551)

v0.3.14

Fixes

• Flexbox: Fix issue where constraints were not being propagated, causing nodes with inherent aspect-ratio (typically images) to not apply that aspect-ratio (#545) (Fixes bevyengine/bevy#9841)

v0.3.13

Fixes

• Fix rounding accumulation bug (#521) (Fixes #501 and bevyengine/bevy#8911)

• Flexbox: pass correct cross-axis available space when computing an item's intrinsic main size (#522)(Fixes bevyengine/bevy#9350)

• Flexbox: Subtract child margin not parent margin when computing stretch-alignment known size

• Grid: Make CSS Grid algorithm correctly apply max width/height and available space when it is the root node (#491)

• Grid: Fix CSS Grid "auto track" / placement bugs #481

  • Fix divide by zero when using grid_auto_rows/grid_auto_columns with zero negative implicit tracks
  • Fix over counting of tracks (leading to incorrect container heights) when auto-placing in grids that contain negative implicit tracks.
  • Fix axis conflation in auto-placement code when grid_auto_flow is column
  • Fix assignment of auto track sizes when initializing negative implicit tracks

• Leaf: Apply margins to leaf nodes when computing available space for measure functions

• Leaf: Reserve space for padding/borders in nodes with measure functions (#497)

  NOTE: This has the potential to break layouts relying on the old behaviour. However, such layouts would be relying on a style having no effect, so it is judged that such layouts are unlikely to exist in the wild. If this turns out not to be true then this fix will be reverted on the 0.3.x branch.

Dependencies

• Upgrade grid to 0.10. This eliminates the transitive dependency on no-std-compat.

v0.3.12

Fixes

• Fix caching issue when toggling display:none on and off

v0.3.11

Fixes

• Fix exponential blowup when laying out trees containing nodes with min and max sizes.

v0.3.10

Fixes

• Fix sizing of children when the available_space < min_size (#407)