A List Apart

Faux Absolute Positioning

There are two popular approaches to positioning with CSS: float and absolute positioning. Both approaches have their pros and cons. My teammates and I have developed a new positioning approach that gives us the best of both worlds. After quite a bit of experimenting and testing, it’s time to share the technique with the rest of the world and see how we can work together to improve it. I’m calling it “faux absolute positioning” after the faux columns technique that simulates the presence of a column.

Many website designs are based on a columnar layout with a header and footer. With absolutely positioned layouts, it is almost impossible to position the footer if the columns can grow vertically. With floated layouts, unexpected content changes can cause entire columns to wrap (“float drop”), as described by Shaun Inman in Clearance. This is undesirable and hard to control in Internet Explorer because of IE’s problematic treatment of width.

Our use case was even more complex: my team was developing a web-based WYSIWYG form generator that allows the user to drag items to arbitrary locations on a canvas. We needed to let our users create beautiful forms that didn’t use overly static layouts and to let them align columns as needed.

For example, let’s assume we want a form that puts the postal code and city fields on the same line because they are semantically connected. To accomplish this, we tried using floated positioning inspired by the Holy Grail technique. Using this method, we needed to adjust the width, borders, margins, and/or padding of the postal code field to pin the city field to a fixed horizontal position. That was a problem because if the width of the postal code field needed adjusting, or if we wanted to adjust the amount of whitespace between fields, the city field would need to move as well. The more elements on a page—the more cells in your grid—the more tedious this kind of adjustment becomes. Additionally, the positioning is sensitive to the slightest change in a number of parameters, which makes it nigh impossible to control in case of dynamic form items.

Next, we tried using absolute positioning. This gave us much more control over the positioning of the items and is robust. But absolutely positioned elements have no height, and that caused the containing element (the canvas) to collapse. This made it hard to position content without making everything absolutely positioned—which is impossible to achieve with dynamic content.

A different approach

Finally, we tried a solution based on finding a way to calculate the left offset from a fixed position, as opposed to calculating it from the right edge of the preceding element. We managed to do this using a combination of position: relative, left: 100% and a negative margin-left.

Our method starts by building a grid of lines and items. We can place any number of items on a line and any number of lines in the containing element:

To position a particular item, all we need to do is give it a negative margin-left and a width. For example:

#item1 {
margin-left: -100%;
width: 30%;
}

With some extra styling, for demonstration purposes, it looks like this:

Example of Faux Absolute Positioning in action.

The generic CSS positions every item at the right side of the canvas, with each item’s width based on its content and all items floated in their HTML source order. The margin-left is now offset from the right side of the canvas instead of from the element to its left.

Advantages

With faux absolute positioning, we can align every item to a predefined position on the grid (as with absolute positioning) but items still affect the normal flow and—thanks to clear—have many of the same advantages as normal-flow elements. Every row in the grid will always have height dependent on the content or as defined in CSS, and will always take up 100% of the width, no matter how many columns are defined in the row. Furthermore, we can avoid using cumbersome margins or padding to adjust the amount of whitespace between elements—which is a plus, since those techniques almost always require us to use IE6-specific hacks to compensate for the browser’s box model.

Another advantage of the technique is that it mitigates much of the fragility of floats. When the content of a floated box is wider than the box itself, it pushes the next box to the right (and by consequence, the box often drops down). With faux absolute positioning, the box to the right stays in place, no matter what. The content of the boxes may overlap (depending on other variables such as overflow: hidden) but that’s all—and in our view, it’s better to risk overlap than risk breaking the whole layout.

Honestly, I was a bit surprised that the technique worked so well. It uses valid HTML 4.01 and CSS 2.1, and negative left margins are widely implemented in browsers. And there’s more good news: it works with fixed and liquid designs, it can be combined with equal height columns (though the issues with this solution remain), and there is the possibility of combining fixed-width and flexible-width columns (see the example below). It is even possible to use faux absolute positioning recursively, e.g., use a positioned item as the container for new lines and items.

Downsides

Faux absolute positioning is very much inspired by and intended for grid-based design and is more rewarding with more complex layouts. If you have a two-column fixed-width design, this may not be your technique of choice.

Additionally, faux absolute positioning will not work for every situation. If you want to align elements on the left, you cannot use a unit that is different from the unit in which the width of the canvas is defined, because you cannot calculate the offset. For example, if you have a canvas width: 800px and want a left offset of 2em for your item you cannot calculate the margin-left because you never know how many ems fit in 800 pixels.

And since it is a new technique that hasn’t been tested by thousands of users, it should still be considered experimental, as you may see unexpected results in your actual combination of markup, CSS, and browser.

One remaining issue: when an element larger than the canvas precedes other elements in the HTML source, the trailing elements on the same line will be pushed to the right by an amount equal to the difference in width between the the first element and the canvas.

Examples

The first example is a three-column liquid layout with fixed side columns, like the Holy Grail. I have implemented this layout as a template for Drupal, a popular open source CMS. There are a few things to note:

The left and right columns have widths in pixels. Therefore, we cannot calculate margin-left for the main content, because we don’t know the width of the canvas or the width of the left column as a percentage of the canvas. The solution is similar to the Holy Grail: position the main content with margin-left: -100% and width: 100% and add padding to provide the necessary space for the columns.

Left, main, and right columns are rendered at the same hierarchical level, so we may need something like z-index: 100 on the columns.

Padding for the left and right columns is added to the extra div.sap-content; this keeps our math simple while affording us a great deal of flexibility.

The second example is a five-column liquid design in which canvas, lines, and items are all sized in percentages. The addition of images, borders and paddings have no effect on the overall positioning, even for images that are larger than the containing element, as is demonstrated with the old map of Maastricht in the example.

No hacks required!

Our approach requires no hacks and it works with all modern browsers (Safari, Opera, Firefox, IE7) as well as IE6 and even IE5.5/Win. It does not work in IE5/Mac, but since this product has been discontinued, it is not on our priority list.

The approach is also very stable, since elements grow vertically if necessary, and the layout does not break when an image is wider than the element, for example. The positioning of items is independent from the source order in HTML.

I am quite enthusiastic about this approach and see many opportunities for it. Feel free to try, experiment and post your comments.

About the Author

Eric Sol is founder of a small software firm based in beautiful Maastricht, The Netherlands. He has held several positions in Dutch higher education, both in ICT and policy making. He started his journey into CSS in October, 2006. Besides having a family he likes cycling and listening to his collection of vinyl and CDs.