CSS Display Module Level 3

Status: WD
Date: 2015-07-21
Work Status: Revising
ED: http://dev.w3.org/csswg/css-display/
Shortname: css-display
Group: csswg
Level: 3
TR: http://www.w3.org/TR/css-display-3/
Previous Version: http://www.w3.org/TR/2014/WD-css-display-3-20140911/
Editor: Tab Atkins Jr., Google, http://xanthir.com/contact/
Editor: fantasai, Invited Expert, http://fantasai.inkedblade.net/contact
Abstract: This module describes how the CSS formatting box tree is generated from the document element tree and defines the 'display' and 'box-suppress' properties that control it.
Ignored Terms: display-model, display-role, table row group box

Introduction

This section is normative. CSS takes a source document, organized as a tree of elements, and renders it onto a canvas (such as your screen, a piece of paper, or an audio stream). To do this, it generates an intermediary structure, the box tree, which represents the formatting structure of the rendered document. Each box represents its corresponding element (or pseudo-element) in space and/or time on the canvas. To create the box tree, CSS first uses cascading and inheritance, to assign a value for each CSS property to each element in the source tree. (See [[!CSS3-CASCADE]].) Then, for each element, it generates zero or more boxes as specified by that element's 'display' and 'box-suppress' properties. Typically, an element generates a single box. However, some 'display' values (e.g. ''display: list-item'') generate more than one box (e.g. a principal block box and a marker box). And some values (such as ''display:none'', ''display: contents'', and ''box-suppress: discard'') cause the element and/or its descendants to not generate any boxes at all. Boxes are assigned the same styles as their generating element, unless otherwise indicated. They're often referred to by their 'display' type-- e.g. a box generated by an element with ''display: block'' is called a “block box” or just a “block”. An anonymous box is is a box that is not associated with any element. Anonymous boxes are generated in certain circumstances to fix up the box tree when it requires a particular nested structure that is not provided by the boxes generated from the element tree. For example, a table cell box requires a particular type of parent box (the table row box), and will generate an anonymous table row box around itself if its parent is not a table row box. (See [[CSS2]] § 17.2.1.) Unlike element-generated boxes, whose styles inherit strictly through the element tree, anonymous boxes (which only exist in the box tree) inherit through their box tree parentage. In the course of layout, a box may be broken into multiple fragments. This happens, for example, when an inline box is broken across lines, or when a block box is broken across pages or columns. A box therefore consists of one or more box fragments. See [[CSS3-BREAK]] for more information on fragmentation. Note: Many of the CSS specs were written before this terminology was ironed out, or refer to things incorrectly, so view older specs with caution when they're using these terms. It should be possible to infer from context which term they really mean. Please report errors in specs when you find them, so they can be corrected. Note: Further information on the “aural” box tree and its interaction with the 'display' property can be found in the CSS Speech Module. [[!CSS3-SPEECH]]

Module interactions

This module replaces and extends the definition of the 'display' property defined in [[!CSS2]] section 9.2.4. None of the properties in this module apply to the ::first-line or ::first-letter pseudo-elements.

Values

This specification follows the CSS property definition conventions from [[!CSS2]]. In addition to the property-specific values listed in their definitions, all properties defined in this specification also accept the CSS-wide keywords as their property value. For readability it has not been repeated explicitly.

Box Layout Modes: the 'display' property

	Name: display
	Value: [ <> || <> ] | <> | <> | <> | <>
	Initial: inline
	Applies to: all elements
	Inherited: no
	Computed value: as specified
	Animatable: no
	Media: all
	
The 'display' property defines box's display type, which consists of the two basic qualities of how an element generates boxes: * the inner display type, which defines the kind of formatting context it generates, dictating how its descendant boxes are laid out. * the outer display type, which dictates how the box participates in its parent formatting context. Some 'display' values have additional side-effects: such as ''list-item'', which also generates a ''::marker'' pseudo-element, and ''none'', which causes the element's entire subtree to be left out of the box tree. Values are defined as follows:
	<display-outside>  = block | inline | run-in ;
	<display-inside>   = flow | flow-root | table | flex | grid | ruby ;
	<display-listitem> = list-item && <>? && [ flow | flow-root ]?
	<display-internal> = table-row-group | table-header-group |
	                     table-footer-group | table-row | table-cell |
	                     table-column-group | table-column | table-caption |
	                     ruby-base | ruby-text | ruby-base-container |
	                     ruby-text-container ;
	<display-box>      = contents | none ;
	<display-legacy>   = inline-block | inline-list-item |
	                     inline-table | inline-flex | inline-grid ;
	
The following informative table summarizes the values of 'display':
Short 'display' Full 'display' Generated box
''none'' subtree omitted from box tree
''contents'' element replaced by contents in box tree
''block'' ''block flow'' block-level block container aka block box
''flow-root'' ''block flow-root'' block-level block container that establishes a new block formatting context (BFC)
''inline'' ''inline flow'' inline box
''inline-block'' ''inline flow-root'' inline-level block container
''run-in'' ''run-in flow'' run-in box (inline box with special box-tree-munging rules)
''list-item'' ''list-item block flow'' block box with additional marker box
''inline list-item'' ''list-item inline flow'' inline box with additional marker box
''flex'' ''block flex'' block-level flex container
''inline-flex'' ''inline flex'' inline-level flex container
''grid'' ''block grid'' block-level grid container
''inline-grid'' ''inline grid'' inline-level grid container
''ruby'' ''inline ruby'' inline-level ruby container
''block ruby'' ''block ruby'' block box containing ruby container
''table'' ''block table'' block-level table wrapper box containing table box
''inline-table'' ''inline table'' inline-level table wrapper box containing table box
''table-cell'' ''table-cell flow'' table cell block container
''table-caption'' ''table-caption flow'' table cell block container
''ruby-base'' ''ruby-base flow'' layout-specific internal box
''ruby-text'' ''ruby-text flow'' layout-specific internal box
other <> layout-specific internal box
Note: Following the precedence rules of “most backwards-compatible, then shortest”, serialization of equivalent 'display' values uses the “Short 'display'” column. [[CSSOM]]

Outer Display Roles for Flow Layout: the ''block'', ''inline'', and ''run-in'' keywords

The <> keywords specify the element's outer display type, which is essentially its role in flow layout. They are defined as follows:
block
The element generates a block-level box. [[!CSS2]]
inline
The element generates an inline-level box. [[!CSS2]]
run-in
The element generates a run-in box. Run-in elements act like inlines or blocks, depending on the surrounding elements. See [[#run-in]] for details.
If a <> value is specified but <> is omitted, the element's inner display type defaults to ''flow''.

Inner Display Layout Models: the ''flow'', ''flow-root'', ''table'', ''grid'', and ''ruby'' keywords

The <> keywords specify the element's inner display type, which defines the type of formatting context that lays out its contents. They are defined as follows:
flow
The element lays out its contents using flow layout (block-and-inline layout). If its outer display type is ''inline'' or ''run-in'', and it is participating in a block or inline formatting context, then it generates an inline box. Otherwise it generates a block container box. Depending on the value of other properties (such as 'position', 'float', or 'overflow') and whether it is itself participating in a block or inline formatting context, it either establishes a new block formatting context for its contents or integrates its contents into its parent formatting context. See CSS2.1 Chapter 9. [[!CSS2]]
flow-root
The element generates a block container box, and lays out its contents using flow layout. It always establishes a new block formatting context for its contents. [[!CSS2]]
table
The element generates a principal table wrapper box containing an additionally-generated table box, and establishes a table formatting context. [[!CSS2]]
flex
The element generates a principal flex container box and establishes a flex formatting context. [[!CSS3-FLEXBOX]]
grid
The element generates a principal grid container box, and establishes a grid formatting context. [[!CSS3-GRID-LAYOUT]]
ruby
The element generates a principal ruby container box, and establishes a ruby formatting context. [[!CSS3RUBY]]
If a <> value is specified but <> is omitted, the element's outer display type defaults to ''block''-- except for ''ruby'', which defaults to ''inline''.

Generating Marker Boxes: the ''list-item'' keyword

The list-item keyword causes the element to generate a ''::marker'' pseudo-element box [[!CSS-PSEUDO-4]] with the content specified by its 'list-style' properties (CSS 2.1§12.5 Lists) [[!CSS2]] together with a principal box of the specified type for its own contents. If no <> value is specified, the principal box's inner display type defaults to ''flow''. If no <> value is specified, the principal box's outer display type defaults to ''block''. Note: In this level, as restricted in the grammar, a list-item can only be a block box, a block formatting context root box, an inline box, or an inline-block box. This restriction may be relaxed in a future level of this module.

Layout-Internal Display Types: the ''table-*'' and ''ruby-*'' keywords

Some layout models, such as ''table'' and ''ruby'', have a complex internal structure, with several different roles that their children and descendants can fill. This section defines those "internal" 'display' values, which only have meaning within that particular layout mode. Unless otherwise specified, both the inner display type and the outer display type of elements using these 'display' values are set to the given keyword. The <> keywords are defined as follows:
table-row-group, table-header-group, table-footer-group, table-row, table-cell, table-column-group, table-column, table-caption
The element is an internal table element, and participates in a table layout context. [[!CSS2]] ''table-cell'' and ''table-caption'' have a ''flow'' inner display type.
ruby-base, ruby-text, ruby-base-container, ruby-text-container
The element is an internal ruby element, and participates in a ruby layout context. [[!CSS3RUBY]] ''ruby-base'' and ''ruby-text'' have a ''flow'' inner display type.
Boxes with layout-specific display types generate anonymous wrapper boxes around themselves when placed in an incompatible parent, as defined by their respective specifications.
For example, Table Layout requires that a ''table-cell'' box must have a ''table-row'' parent box. If it is misparented, like so:
		<div style="display:block;">
			<div style="display:table-cell">...</div>
		</div>
		
It will generate wrapper boxes around itself, producing a structure like:
		block box
		└anonymous table box
		 └anonymous table-row-group box
		  └anonymous table-row box
		   └table-cell box
		
Even if the parent is another internal table element, if it's not the correct one, wrapper boxes will be generated. For example, in the following markup:
		<div style="display:table;">
			<div style="display:table-row">
				<div style="display:table-cell">...</div>
			</div>
		</div>
		
Anonymous wrapper box generation will produce:
		table box
		└anonymous table-row-group box
		 └table-row box
		  └table-cell box
		
This "fix-up" ensures that table layout has a predictable structure to operate on.

Box Generation: the ''none'' and ''contents'' keywords

While 'display' can control the types of boxes an element will generate, it can also control whether an element will generate any boxes at all. The <> keywords are defined as follows:
contents
The element itself does not generate any boxes, but its children and pseudo-elements still generate boxes as normal. For the purposes of box generation and layout, the element must be treated as if it had been replaced with its children and pseudo-elements in the document tree. Issue: ''contents'' currently only has an effect on box generation and layout. Other things that care about the document tree are unaffected, like counter scopes. Is this what we want?
none
The element and its descendants generates no boxes. Advisement: It is recommended that 'box-suppress' be used instead of ''display: none'', so that the element's display type is automatically preserved for when it's no longer suppressed.
Elements with either of these values do not have inner or outer display types, because they don't generate any boxes at all.

Precomposed Inline-level Display Values

CSS level 2 used a single-keyword syntax for 'display', requiring separate keywords for block-level and inline-level variants of the same layout mode. These <> keywords map as follows:
inline-block
Behaves as ''inline flow-root''.
inline-table
Behaves as ''inline table''.
inline-flex
Behaves as ''inline flex''.
inline-grid
Behaves as ''inline grid''.

Automatic Box Type Transformations

Some layout effects require blockification or inlinification of the box type, which sets the box’s outer display type, if it is not ''none'' or ''contents'', to ''block'' or ''inline'' (respectively).
Some examples of this include:
  • Absolute positioning or floating an element blockifies the box’s display type. [[CSS2]]
  • Containment in a ruby container inlinifies the box’s display type, as described in [[CSS3RUBY]].
  • A parent with a ''grid'' or ''flex'' 'display' value blockifies the box’s display type. [[CSS3-GRID-LAYOUT]] [[CSS3-FLEXBOX]]
If a box with a ''flow'' inner display type is blockified, its inner display type becomes ''flow-root''. If a box with a ''flow'' inner display type is inlinified, it recursively inlinifies all of its in-flow children, so that no block-level descendants break up the inline formatting context in which it participates. The root element’s display type is always blockified. Additionally, a 'display' of ''contents'' computes to ''block'' on the root element.

Toggling Box Generation: the 'box-suppress' property

	Name: box-suppress
	Value: show | discard | hide
	Initial: show
	Applies to: all elements
	Inherited: no
	Percentages: n/a
	Computed value: see prose
	Media: all
	
The ''display: none'' value was historically used as a "toggle" to switch between showing and hiding an element. Making this reversible requires either setting up the CSS cascade carefully, or remembering what the 'display' value was before it was set to ''none''. To make this common use-case easier, this module introduces the separate 'box-suppress' property to do the same thing, so that toggling whether or not an element appears in the formatting tree can now be done without affecting its display type when it is displayed. If the computed value of 'display' is ''none'', the computed value of 'box-suppress' is ''discard''. Otherwise, the computed value is the specified value. Values have the following meanings:
show
The element generates boxes as normal, per its 'display-*' properties.
discard
The element generates no boxes at all.
hide
The element generates boxes as normal, but those boxes do not participate in layout in any way, and must not be displayed. For the purpose of any layout-related information, such as querying for the computed value of the element's 'width' property, it must be treated as if it did not generate any boxes. Properties that rely on boxes but do not rely on layout, such as animations, 'counter-increment', etc., must work as normal on this element and its descendants. Issue: This needs more clarity about what "layout-related" and "participates in layout" means. Does the box still generate anonymous boxes, etc.? How does it affect speech? See proposal.
Issue: We welcome better naming suggestions on this property. Issue: Please send use cases (examples of where this property or something close to it is useful and necessary) to the CSSWG so that we can be sure we're designing the details of its behavior correctly.

Run-In Layout

A run-in box is a box that merges into a block that comes after it, inserting itself at the beginning of that block’s inline-level content. This is useful for formatting compact headlines, definitions, and other similar things, where the appropriate DOM structure is to have a headline preceding the following prose, but the desired display is an inline headline laying out with the text.
For example, dictionary definitions are often formatted so that the word is inline with the definition:
		<dl class='dict'>
			<dt>dictionary
			<dd>a book that lists the words of a language in alphabetical
			    order and gives their meaning, or that gives the equivalent
			    words in a different language.
			<dt>glossary
			<dd>an alphabetical list of terms or words found in or relating
			    to a specific subject, text, or dialect, with explanations; a
			    brief dictionary.
		</dl>
		<style>
		.dict > dt {
			display: run-in;
		}
		.dict > dt::after {
			content: ": "
		}
		</style>
		
Which is formatted as:
		dictionary: a book that lists the words of a language
		in alphabetical order and explains their meaning.

		glossary: an alphabetical list of terms or words found
		in or relating to a specific subject, text, or dialect,
		with explanations; a brief dictionary.
		
A run-in box behaves exactly as an inline-level box, except:
  • If a run-in sequence is immediately followed by a block box that does not establish a new formatting context, it is inserted as direct children of the block box after its ''::marker'' pseudo-element's boxes (if any), but preceding any other boxes generates by the contents of the block (including the box generated by the ''::before'' pseudo-element, if any). The reparented content is then formatted as if originally parented there. Note that only layout is affected, not inheritance, because property inheritance for non-anonymous boxes is based only on the element tree.
  • Otherwise, an anonymous block box is generated around the run-in sequence and all immediately following inline-level content (up to, but not including, the next run-in sequence, if any).
  • A run-in box with ''display: flow'' inlinifies its contents.
A run-in sequence is a maximal sequence of consecutive sibling run-in boxes and intervening white space and/or out-of-flow boxes. Issue: Should out-of-flow elements get reparented, left behind, or break apart the sequence? See thread. Note: This run-in model is slightly different from the one proposed in earlier revisions of [[!CSS2]]. Issue: Interaction of run-in and ::first-letter

Appendix A: Glossary

The following terms are defined here for convenience:
inline-level
Content that participates in inline layout. Specifically, inline-level boxes and text.
block-level
Content that participates in block layout. Specifically, block-level boxes.
inline
A non-replaced inline-level box whose inner display type is ''flow''. The contents of an inline box participate in the same inline formatting context as the inline box itself.
atomic inline
An inline-level box that is replaced or that establishes a new formatting context. (An inline-level box whose inner display type is not ''flow'' establishes a new formatting context of the specified inner display type.)
block container
A box whose contents participate in a block formatting context. A block container does not necessarily establish a new block formatting context if its parent formatting context is also a block formatting context.
block box
A block-level box that is also a block container.
block
Used as a shorthand for block box, block-level box, or block container box, where unambiguous.
containing block
A rectangle that forms the basis of sizing and positioning for the boxes associated with it (usually the children of the box that generated it). Notably, a containing block is not a box (it is a rectangle), however it is often derived from the dimensions of a box. If properties of a containing block are referenced, they reference the values on the box that generated the containing block. (For the initial containing block, the values are taken from the root element.) See [[CSS2]] Section 9.1.2 and Section 10.1 for details.
initial containing block
The containing block of the root element. See CSS2.1§10.1 for continuous media; and [[!CSS3PAGE]] for paged media.
formatting context
A formatting context is the environment into which a set of related boxes are laid out. Different formatting contexts lay out their boxes according to different rules. For example, a flex formatting context lays out boxes according to the flex layout rules [[CSS3-FLEXBOX]], whereas a block formatting context lays out boxes according to the block-and-inline layout rules [[CSS2]]. When a box establishes a new formatting context (whether that formatting context is of the same type as its parent or not), it essentially creates a new, independent layout environment: except through the sizing of the box itself, the layout of its descendants is (generally) not affected by the the rules and contents of the formatting context outside the box, and vice versa.

For example, in a block formatting context, floated boxes affect the layout of surrounding boxes. But their effects do not escape their formatting context: the box establishing their formatting context grows to fully contain them, and floats from outside that box are not allowed to protrude into and affect the contents inside the box.

As another example, margins do not collapse across formatting context boundaries.

Exclusions are able to affect content across formatting context boundaries. (At time of writing, they are the layout feature that can.) [[CSS3-EXCLUSIONS]]

block formatting context
inline formatting context
Block and inline formatting contexts are defined in CSS 2.1 Section 9.4.
BFC
Informal abbreviation for block formatting context. Often used to refer to a block formatting context root, that is, a block box that establishes a new block formatting context for its contents.
See [[!CSS2]] Chapter 9 for a fuller definition of these terms.

Acknowledgments

We would like to thank the many people who have attempted to separate out the disparate details of box generation over the years, most particularly Bert Bos, whose last attempt with 'display-model' and 'display-role' didn't get anywhere, but primed us for the current spec, and Anton Prowse, whose relentless assault on CSS2.1 Chapter 9 forced some order out of the chaos. We would also like to thank the many JavaScript libraries such as jQuery which have hacked around the "what 'display' should I give it when you call .show()?" problem, making it extremely clear that something needed to be done on our part.

Changes

Changes since the 11 September 2014 Working Draft include:
  • Removed display-inside, display-outside, and display-extras longhands, in favor of just making 'display' multi-value. (This was done to impose constraints on what can be combined. Future levels of this specification may relax some or all of those restrictions if they become unnecessary or unwanted.)
  • Created the ''flow'' and ''flow-root'' inner display types to better express flow layout display types and to create an explicit switch for making an element a BFC root. (This should eliminate the need for hacks like ''::after { clear: both; }'' and ''overflow: hidden'' that are intended to accomplish this purpose.)