Module compute 

Low-level access to the layout algorithms themselves. For a higher-level API, see the TakiaTree struct.

Layout functions

The layout functions all take an &mut impl LayoutPartialTree parameter, which represents a single container node and it’s direct children.

Function	Purpose
compute_flexbox_layout	Layout a Flexbox container and it’s direct children
compute_grid_layout	Layout a CSS Grid container and it’s direct children
compute_block_layout	Layout a Block container and it’s direct children
compute_leaf_layout	Applies common properties like padding/border/aspect-ratio to a node before deferring to a passed closure to determine it’s size. Can be applied to nodes like text or image nodes.
compute_root_layout	Layout the root node of a tree (regardless of it’s layout mode). This function is typically called once to begin a layout run.
compute_hidden_layout	Mark a node as hidden during layout (like Display::None)
compute_cached_layout	Attempts to find a cached layout for the specified node and layout inputs. Uses the provided closure to compute the layout (and then stores the result in the cache) if no cached layout is found.

Other functions

Function	Requires	Purpose
round_layout	RoundTree	Round a tree of float-valued layouts to integer pixels
print_tree	PrintTree	Print a debug representation of a node tree and it’s computed layout

Modules

detailed_info

A module for unified re-exports of detailed layout info structs, used by low level API

Structs

BfcSlotfloat_layout

An empty “slot” that avoids floats that is suitable for a box that establishes an independent formatting context (and therefore must not overlap floats) to be laid out into. Unlike ContentSlot, this accounts for the box’s own margins, which are resolved against the containing block’s edges (not float edges) and may therefore overlap floats.

BlockContextblock_layout

Context for each individual Block within a Block Formatting Context

BlockFormattingContextblock_layout

Context for positioning Block and Float boxes within a Block Formatting Context

ContentSlotfloat_layout

An empty “slot” that avoids floats that is suitable for non-floated content to be laid out into

FloatContextfloat_layout

A context for placing floated boxes

FloatIntrinsicWidthCalculatorfloat_layout

Context for computing the intrinsic width contribution of a set of floats

FloatMarkblock_layout and float_layout

A mark of how many floats a Block Formatting Context held when it was taken. See BlockContext::float_mark.

OofLayoutResult

The result of laying out out-of-flow candidates against an explicit positioning area.

Functions

compute_block_align_content_offsetblock_layout

Compute the block-axis offset that align-content applies to the in-flow content of a block container, given the free space between the container’s content box and its content.

compute_block_layoutblock_layout

Computes the layout of LayoutPartialTree according to the block layout algorithm

compute_cached_layout

Attempts to find a cached layout for the specified node and layout inputs.

compute_flexbox_layoutflexbox

Computes the layout of a box according to the flexbox algorithm

compute_grid_layoutgrid

Grid layout algorithm This consists of a few phases:

compute_hidden_layout

Creates a layout for this node and its children, recursively. Each hidden node has zero size and is placed at the origin

compute_leaf_layout

Compute the size of a leaf node (node with no children)

compute_oof_layout

Run the out-of-flow positioning pass for node_id after its layout algorithm has produced output: lay out the out-of-flow candidates in output.oof_candidates for which the node is the containing block, record them as the node’s hoisted children, and replace output.oof_candidates with the unclaimed remainder (which bubble further up the tree). The scrollable overflow contributed by the claimed boxes is merged into output.scrollable_overflow_rect.

compute_oof_layout_for_area

Lay out out-of-flow candidates against an explicit positioning area.

compute_root_layout

Compute layout for the root node in the tree

resolve_static_offset

Resolve the final static offset of an out-of-flow box from its static position, given the box’s final size and resolved margins.

round_layout

Rounds the calculated layout to exact pixel values