Let's build a browser engine!

Part 6: Block layout

Welcome back to my series on building a toy HTML rendering engine:

This article will continue the layout module that we started in Part 5. This time, we'll add the ability to lay out block boxes. These are boxes that are stack vertically, such as headings and paragraphs.

To keep things simple, this code implements only normal flow: no floats, no absolute positioning, and no fixed positioning.

Traversing the Layout Tree

The entry point to this code is the layout function, which takes a takes a LayoutBox and calculates its dimensions. We'll break this function into three cases, and implement only one of them for now:

impl LayoutBox { // Lay out a box and its descendants. fn layout ( & mut self , containing_block : Dimensions ) { match self . box_type { BlockNode ( _ ) => self . layout_block ( containing_block ), InlineNode ( _ ) => {} // TODO AnonymousBlock => {} // TODO } } // ... }

A block's layout depends on the dimensions of its containing block. For block boxes in normal flow, this is just the box's parent. For the root element, it's the size of the browser window (or "viewport").

You may remember from the previous article that a block's width depends on its parent, while its height depends on its children. This means that our code needs to traverse the tree top-down while calculating widths, so it can lay out the children after their parent's width is known, and traverse bottom-up to calculate heights, so that a parent's height is calculated after its children's.

fn layout_block ( & mut self , containing_block : Dimensions ) { // Child width can depend on parent width, so we need to calculate // this box's width before laying out its children. self . calculate_block_width ( containing_block ); // Determine where the box is located within its container. self . calculate_block_position ( containing_block ); // Recursively lay out the children of this box. self . layout_block_children (); // Parent height can depend on child height, so `calculate_height` // must be called *after* the children are laid out. self . calculate_block_height (); }

This function performs a single traversal of the layout tree, doing width calculations on the way down and height calculations on the way back up. A real layout engine might perform several tree traversals, some top-down and some bottom-up.

Calculating the Width

The width calculation is the first step in the block layout function, and also the most complicated. I'll walk through it step by step. To start, we need the values of the CSS width property and all the left and right edge sizes:

fn calculate_block_width ( & mut self , containing_block : Dimensions ) { let style = self . get_style_node (); // `width` has initial value `auto`. let auto = Keyword ( "auto" . to_string ()); let mut width = style . value ( "width" ). unwrap_or ( auto . clone ()); // margin, border, and padding have initial value 0. let zero = Length ( 0.0 , Px ); let mut margin_left = style . lookup ( "margin-left" , "margin" , & zero ); let mut margin_right = style . lookup ( "margin-right" , "margin" , & zero ); let border_left = style . lookup ( "border-left-width" , "border-width" , & zero ); let border_right = style . lookup ( "border-right-width" , "border-width" , & zero ); let padding_left = style . lookup ( "padding-left" , "padding" , & zero ); let padding_right = style . lookup ( "padding-right" , "padding" , & zero ); // ... }

This uses a helper function called lookup , which just tries a series of values in sequence. If the first property isn't set, it tries the second one. If that's not set either, it returns the given default value. This provides an incomplete (but simple) implementation of shorthand properties and initial values.

Note: This is similar to the following code in, say, JavaScript or Ruby: margin_left = style["margin-left"] || style["margin"] || zero;

Since a child can't change its parent's width, it needs to make sure its own width fits the parent's. The CSS spec expresses this as a set of constraints and an algorithm for solving them. The following code implements that algorithm.

First we add up the margin, padding, border, and content widths. The to_px helper method converts lengths to their numerical values. If a property is set to 'auto' , it returns 0 so it doesn't affect the sum.

let total = [ & margin_left , & margin_right , & border_left , & border_right , & padding_left , & padding_right , & width ]. iter (). map ( | v | v . to_px ()). sum ();

This is the minimum horizontal space needed for the box. If this isn't equal to the container width, we'll need to adjust something to make it equal.

If the width or margins are set to 'auto' , they can expand or contract to fit the available space. Following the spec, we first check if the box is too big. If so, we set any expandable margins to zero.

// If width is not auto and the total is wider than the container, treat auto margins as 0. if width != auto && total > containing_block . content . width { if margin_left == auto { margin_left = Length ( 0.0 , Px ); } if margin_right == auto { margin_right = Length ( 0.0 , Px ); } }

If the box is too large for its container, it overflows the container. If it's too small, it will underflow, leaving extra space. We'll calculate the underflow—the amount of extra space left in the container. (If this number is negative, it is actually an overflow.)

let underflow = containing_block . content . width - total ;

We now follow the spec's algorithm for eliminating any overflow or underflow by adjusting the expandable dimensions. If there are no 'auto' dimensions, we adjust the right margin. (Yes, this means the margin may be negative in the case of an overflow!)

match ( width == auto , margin_left == auto , margin_right == auto ) { // If the values are overconstrained, calculate margin_right. ( false , false , false ) => { margin_right = Length ( margin_right . to_px () + underflow , Px ); } // If exactly one size is auto, its used value follows from the equality. ( false , false , true ) => { margin_right = Length ( underflow , Px ); } ( false , true , false ) => { margin_left = Length ( underflow , Px ); } // If width is set to auto, any other auto values become 0. ( true , _ , _ ) => { if margin_left == auto { margin_left = Length ( 0.0 , Px ); } if margin_right == auto { margin_right = Length ( 0.0 , Px ); } if underflow >= 0.0 { // Expand width to fill the underflow. width = Length ( underflow , Px ); } else { // Width can't be negative. Adjust the right margin instead. width = Length ( 0.0 , Px ); margin_right = Length ( margin_right . to_px () + underflow , Px ); } } // If margin-left and margin-right are both auto, their used values are equal. ( false , true , true ) => { margin_left = Length ( underflow / 2.0 , Px ); margin_right = Length ( underflow / 2.0 , Px ); } }

At this point, the constraints are met and any 'auto' values have been converted to lengths. The results are the the used values for the horizontal box dimensions, which we will store in the layout tree. You can see the final code in layout.rs.

Positioning

The next step is simpler. This function looks up the remanining margin/padding/border styles, and uses these along with the containing block dimensions to determine this block's position on the page.

fn calculate_block_position ( & mut self , containing_block : Dimensions ) { let style = self . get_style_node (); let d = & mut self . dimensions ; // margin, border, and padding have initial value 0. let zero = Length ( 0.0 , Px ); // If margin-top or margin-bottom is `auto`, the used value is zero. d . margin . top = style . lookup ( "margin-top" , "margin" , & zero ). to_px (); d . margin . bottom = style . lookup ( "margin-bottom" , "margin" , & zero ). to_px (); d . border . top = style . lookup ( "border-top-width" , "border-width" , & zero ). to_px (); d . border . bottom = style . lookup ( "border-bottom-width" , "border-width" , & zero ). to_px (); d . padding . top = style . lookup ( "padding-top" , "padding" , & zero ). to_px (); d . padding . bottom = style . lookup ( "padding-bottom" , "padding" , & zero ). to_px (); d . content . x = containing_block . content . x + d . margin . left + d . border . left + d . padding . left ; // Position the box below all the previous boxes in the container. d . content . y = containing_block . content . height + containing_block . content . y + d . margin . top + d . border . top + d . padding . top ; }

Take a close look at that last statement, which sets the y position. This is what gives block layout its distinctive vertical stacking behavior. For this to work, we'll need to make sure the parent's content.height is updated after laying out each child.

Children

Here's the code that recursively lays out the box's contents. As it loops through the child boxes, it keeps track of the total content height. This is used by the positioning code (above) to find the vertical position of the next child.

fn layout_block_children ( & mut self ) { let d = & mut self . dimensions ; for child in & mut self . children { child . layout ( * d ); // Track the height so each child is laid out below the previous content. d . content . height = d . content . height + child . dimensions . margin_box (). height ; } }

The total vertical space taken up by each child is the height of its margin box, which we calculate like so:

impl Dimensions { // The area covered by the content area plus its padding. fn padding_box ( self ) -> Rect { self . content . expanded_by ( self . padding ) } // The area covered by the content area plus padding and borders. fn border_box ( self ) -> Rect { self . padding_box (). expanded_by ( self . border ) } // The area covered by the content area plus padding, borders, and margin. fn margin_box ( self ) -> Rect { self . border_box (). expanded_by ( self . margin ) } } impl Rect { fn expanded_by ( self , edge : EdgeSizes ) -> Rect { Rect { x : self . x - edge . left , y : self . y - edge . top , width : self . width + edge . left + edge . right , height : self . height + edge . top + edge . bottom , } } }

For simplicity, this does not implement margin collapsing. A real layout engine would allow the bottom margin of one box to overlap the top margin of the next box, rather than placing each margin box completely below the previous one.

The 'height' Property

By default, the box's height is equal to the height of its contents. But if the 'height' property is set to an explicit length, we'll use that instead:

fn calculate_block_height ( & mut self ) { // If the height is set to an explicit length, use that exact length. // Otherwise, just keep the value set by `layout_block_children`. if let Some ( Length ( h , Px )) = self . get_style_node (). value ( "height" ) { self . dimensions . content . height = h ; } }

And that concludes the block layout algorithm. You can now call layout() on a styled HTML document, and it will spit out a bunch of rectangles with widths, heights, margins, etc. Cool, right?

Exercises

Some extra ideas for the ambitious implementer:

Collapsing vertical margins. Relative positioning. Parallelize the layout process, and measure the effect on performance.

If you try the parallelization project, you may want to separate the width calculation and the height calculation into two distinct passes. The top-down traversal for width is easy to parallelize just by spawning a separate task for each child. The height calculation is a little trickier, since you need to go back and adjust the y position of each child after its siblings are laid out.

To Be Continued…

Thank you to everyone who's followed along this far!

These articles are taking longer and longer to write, as I journey further into unfamiliar areas of layout and rendering. There will be a longer hiatus before the next part as I experiment with font and graphics code, but I'll resume the series as soon as I can.

Update: Part 7 is now ready.