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':
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''.
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.)