CSS Display Module Level 3 (original) (raw)

1. 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]

1.1. 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.

1.2. 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.

2. Box Layout Modes: the display property

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:

= block | inline | run-in ; = flow | flow-root | table | flex | grid | ruby ; = list-item && ? && [ flow | flow-root ]? = 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 ; = contents | none ; = 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]

2.1. 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 §4 Run-In Layout for details.

If a value is specified but is omitted, the element’s inner display type defaults to flow.

2.2. 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.

2.3. 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.

2.4. 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-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:

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:

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.

2.5. 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.

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. 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.

2.6. 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.

2.7. 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.

3. Toggling Box Generation: the box-suppress property

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.

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.

We welcome better naming suggestions on this property.

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.

4. 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:

dictionary

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.

glossary

an alphabetical list of terms or words found in or relating to a specific subject, text, or dialect, with explanations; a brief dictionary.

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.

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].

Interaction of run-in and ::first-letter

5. 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 (such as an image) or that establishes a new formatting context (such as an inline-block or inline-table). Any 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.

out-of-flow

in-flow

A box is in-flow if it is floated (via float) or absolutely-positioned (via absolute or fixed positioning). A box is in-flow if it not out-of-flow.

Note: some formatting contexts inhibit floating, so that an element with float: left is not necessarily out-of-flow.

CSS2.1 defines the root element as out-of-flow. This seems to me to be more likely to cause problems in our specs than not. Should we change that definition or copy it over?

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 21 July 2015 Working Draft include:

• Added definitions for in-flow and out-of-flow to glossary.

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

Conformance requirements are expressed with a combination of descriptive assertions and RFC 2119 terminology. The key words "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in the normative parts of this document are to be interpreted as described in RFC 2119. However, for readability, these words do not appear in all uppercase letters in this specification.

All of the text of this specification is normative except sections explicitly marked as non-normative, examples, and notes. [RFC2119]

Examples in this specification are introduced with the words "for example" or are set apart from the normative text with class="example", like this:

Informative notes begin with the word "Note" and are set apart from the normative text with class="note", like this:

Note, this is an informative note.

Advisements are normative sections styled to evoke special attention and are set apart from other normative text with <strong class="advisement">, like this: UAs MUST provide an accessible alternative.

A style sheet is conformant to this specification if all of its statements that use syntax defined in this module are valid according to the generic CSS grammar and the individual grammars of each feature defined in this module.

A renderer is conformant to this specification if, in addition to interpreting the style sheet as defined by the appropriate specifications, it supports all the features defined by this specification by parsing them correctly and rendering the document accordingly. However, the inability of a UA to correctly render a document due to limitations of the device does not make the UA non-conformant. (For example, a UA is not required to render color on a monochrome monitor.)

An authoring tool is conformant to this specification if it writes style sheets that are syntactically correct according to the generic CSS grammar and the individual grammars of each feature in this module, and meet all other conformance requirements of style sheets as described in this module.

So that authors can exploit the forward-compatible parsing rules to assign fallback values, CSS renderers must treat as invalid (and ignore as appropriate) any at-rules, properties, property values, keywords, and other syntactic constructs for which they have no usable level of support. In particular, user agents must not selectively ignore unsupported component values and honor supported values in a single multi-value property declaration: if any value is considered invalid (as unsupported values must be), CSS requires that the entire declaration be ignored.

To avoid clashes with future CSS features, the CSS2.1 specification reserves a prefixed syntax for proprietary and experimental extensions to CSS.

Prior to a specification reaching the Candidate Recommendation stage in the W3C process, all implementations of a CSS feature are considered experimental. The CSS Working Group recommends that implementations use a vendor-prefixed syntax for such features, including those in W3C Working Drafts. This avoids incompatibilities with future changes in the draft.

Once a specification reaches the Candidate Recommendation stage, non-experimental implementations are possible, and implementors should release an unprefixed implementation of any CR-level feature they can demonstrate to be correctly implemented according to spec.

To establish and maintain the interoperability of CSS across implementations, the CSS Working Group requests that non-experimental CSS renderers submit an implementation report (and, if necessary, the testcases used for that implementation report) to the W3C before releasing an unprefixed implementation of any CSS features. Testcases submitted to W3C are subject to review and correction by the CSS Working Group.