CSS Overflow Module Level 3

1. Introduction

In CSS Level 1 [CSS1], placing more content than would fit inside an element with a specified size was generally an authoring error. Doing so caused the content to extend outside the bounds of the element, which would likely cause that content to overlap with other elements.

CSS Level 2 [CSS21] introduced the overflow property, which allows authors to have overflow be handled by scrolling, which means it is no longer an authoring error. It also allows authors to specify that overflow is handled by clipping, which makes sense when the author’s intent is that the content not be shown.

This specification introduces the long-standing de-facto overflow-x and overflow-y properties, adds a clip value, and defines overflow handling more fully.

[Something something max-lines.]

2. Types of Overflow

CSS uses the term overflow to describe the contents of a box that extend outside one of that box’s edges (i.e., its content edge, padding edge, border edge, or margin edge). The term might be interpreted as elements or features that cause this overflow, the non-rectangular region occupied by these features, or, more commonly, as the minimal rectangle that bounds that region. A box’s overflow is computed based on the layout and styling of the box itself and of all descendants whose containing block chain includes the box.

In most cases, overflow can be computed for any box from the bounds and properties of that box itself, plus the overflow of each of its children. However, this is not always the case; for example, when transform-style: preserve-3d [CSS3-TRANSFORMS] is used on some of the children, any of their descendants with transform-style: preserve-3d must also be examined.

There are two different types of overflow, which are used for different purposes by the UA:

• ink overflow
• scrollable overflow

2.1. Ink Overflow

The ink overflow of a box is the part of that box and its contents that creates a visual effect outside of the box’s border box. Ink overflow is the overflow of painting effects defined to not affect layout or otherwise extend the scrollable overflow region, such as box shadows, border images, text decoration, overhanging glyphs (with negative side bearings, or with ascenders/descenders extending outside the em box), outlines, etc.

Since some effects in CSS (for example, the blurs in text-shadow [CSS-TEXT-3] and box-shadow [CSS-BACKGROUNDS-3], which are theoretically infinite) do not define what visual extent they cover, the extent of the ink overflow is undefined.

The ink overflow region is the non-rectangular area occupied by the ink overflow of a box and its contents, and the ink overflow rectangle is the minimal rectangle whose axes are aligned to the box’s axes and that contains the ink overflow region. Note that the ink overflow rectangle is a rectangle in the box’s coordinate system, but might be non-rectangular in other coordinate systems due to transforms. [CSS3-TRANSFORMS]

2.2. Scrollable Overflow

The scrollable overflow of a box is the set of things extending outside of that box’s padding edge for which a scrolling mechanism needs to be provided.

The scrollable overflow region is the non-rectangular region occupied by the scrollable overflow, and the scrollable overflow rectangle is the minimal rectangle whose axes are aligned to the box’s axes and that contains the scrollable overflow region.

The scrollable overflow region is the union of:

• the box’s own content and padding areas
  There’s disagreement on the scrolling model. 2.1 apparently defined that you scrolled the *content* area; the content would overflow the content-box, and you would union that overflow with the content box to find the scrollable area. In particular, this means that the content would be offset by the start-sides padding, but if it overflowed, it would go right to the edge on the end sides. This is what Firefox and IE do.

  At least some authors (and spec authors) instead have the mental model that the padding box is what’s scrollable, so when you scroll to the end of the overflow, there’s the right/bottom padding. Chrome/WebKit do this for the block axis, at least. They’re somewhat inconsistent for the inline axis; there’s something weird about how they handle lineboxes.

  It seems that the block-axis padding is probably web-compatible to honor. It’s unclear that the inline-axis padding will be. Further experimentation is needed.

• all line boxes directly contained by the box
• the border boxes of all boxes for which it is the containing block and whose border boxes are positioned not wholly outside its block-start or inline-start padding edges, accounting for transforms by projecting each box onto the plane of the element that establishes its 3D rendering context. [CSS3-TRANSFORMS]

  Is this description of handling transforms sufficiently accurate?

• the scrollable overflow regions of all of the above boxes (accounting for transforms as described above), provided they themselves have overflow: visible (i.e. do not themselves trap the overflow) and that scrollable overflow is not already clipped (e.g. by the clip property or the contain property).

  should overflow: clip also clip the scrollable overflow or should it remain a pure paint-time operation, which would mean that scrollable overflow, while invisible, would still be scrollable.

  Note: The mask-* properties [CSS-MASKING-1] do not affect the scrollable overflow region.

  Need to evaluate compat of honoring or ignoring clip and clip-path.

• Optionally, additional padding on the end-edge sides, corresponding to the end-side padding of the scroll container, such that the end edges of its in-flow content coincide with the end edges of its content area when scrolled to the end.

  It’s not yet clear if including the end-side padding in the scrollable layer is Web-compatible, so this clause is under investigation. It appears that Chrome and Safari include such padding in the block axis; and the behavior in the inline axis is not clear. <https://github.com/w3c/csswg-drafts/issues/129>

The UA may additionally include the margin areas of boxes for which it is the containing block. The conditions under which such margin areas are included is undefined in this level. This needs further testing and investigation; is therefore deferred in this draft.

Note: The scrollable overflow rectangle is always a rectangle in the box’s own coordinate system, but might be non-rectangular in other coordinate systems due to transforms [CSS3-TRANSFORMS]. This means scrollbars can sometimes appear when not actually necessary.

3. Scrolling and Clipping Overflow: the overflow-x, overflow-y, and overflow properties

These properties specify whether a box’s content (including any ink overflow) is clipped to its padding edge, and if so, whether it is a scroll container that allows the user to scroll clipped parts of its scrollable overflow region into view. The visual viewport of the scroll container (through which the scrollable overflow region can be viewed) coincides with its padding box, and is called the scrollport.

The overflow-x property specifies the handling of overflow in the horizontal direction (i.e., overflow from the left and right sides of the box), and the overflow-y property specifies the handling of overflow in the vertical direction (i.e., overflow from the top and bottom sides of the box).

The overflow property is a shorthand property that sets the specified values of overflow-x and overflow-y in that order. If the second value is omitted, it is copied from the first.

Values have the following meanings:

visible

There is no special handling of overflow, that is, the box’s content is rendered outside the box if positioned there. The box is not a scroll container.

hidden

This value indicates that the box’s content is clipped to its padding box and that the UA must not provide any scrolling user interface to view the content outside the clipping region, nor allow scrolling by direct intervention of the user, such as dragging on a touch screen or using the scrolling wheel on a mouse. However, the content must still be scrollable programatically, for example using the mechanisms defined in [CSSOM-VIEW], and the box is therefore still a scroll container.

clip

Like hidden, this value indicates that the box’s content is clipped to its padding box and that no scrolling user interface should be provided by the UA to view the content outside the clipping region. In addition, unlike overflow: hidden which still allows programmatic scrolling, overflow: clip forbids scrolling entirely, through any mechanism, and therefore the box is not a scroll container.

Unlike hidden, this value does not cause the element to establish a new formatting context.

Note: Authors who also want the box to establish a formatting context may use display: flow-root together with overflow: clip.

scroll

This value indicates that the content is clipped to the padding box, but can be scrolled into view (and therefore the box is a scroll container). Furthermore, if the user agent uses a scrolling mechanism that is visible on the screen (such as a scroll bar or a panner), that mechanism should be displayed whether or not any of its content is clipped. This avoids any problem with scrollbars appearing and disappearing in a dynamic environment. When the target medium is print, overflowing content may be printed; it is not defined where it may be printed.

auto

Like scroll when the box has scrollable overflow; like hidden otherwise. Thus, if the user agent uses a scrolling mechanism that is visible on the screen (such as a scroll bar or a panner), that mechanism will only be displayed if there is overflow.

If the computed value of overflow on a block box is neither visible nor clip nor a combination thereof, it establishes an independent formatting context for its contents.

3.1. Overflow in Print and Other Static Media

Since scrolling is not possible in static media (such as print) authors should be careful to make content accessible in such media, for example by using @media print, (update: none) { … } to adjust layout such that all relevant content is simultaneously visible.

On scroll containers in static media with an overflow value of auto or scroll (but not hidden) UAs may display an indication of any scrollable overflow, such as by displaying scrollbars or an ellipsis.

Note: Not all paged media is static; for example, e-book readers page content, but are interactive.

3.2. Scrollbars and Layout

In the case of a scrollbar being placed on an edge of the element’s box, it should be inserted between the inner border edge and the outer padding edge. Any space taken up by the scrollbars should be taken out of (subtracted from the dimensions of) the containing block formed by the element with the scrollbars.

import examples from [CSS3-BOX].

3.3. Scrolling Origin, Direction, and Restriction

The initial scroll position, that is, the initial position of the box’s scrollable overflow region with respect to its border box, prior to any user or programmatic scrolling that changes it, is dependent on the box’s writing mode, and is by default the block-start/inline-start edge of the box’s padding edge. However, the align-content and justify-content properties [CSS-ALIGN-3] can be used to change this, see CSS Box Alignment 3 §5.3 Overflow and Scroll Positions.

Due to Web-compatibility constraints (caused by authors exploiting legacy bugs to surreptitiously hide content from visual readers but not search engines and/or speech output), UAs must clip the scrollable overflow region of scroll containers on the block-start and inline-start sides of the box (thereby behaving as if they had no scrollable overflow on that side).

The viewport uses the principal writing mode for these calculations.

3.4. Overflow Viewport Propagation

UAs must apply the overflow-* values set on the root element to the viewport. However, when the root element is an [HTML] html element (including XML syntax for HTML) whose overflow value is visible (in both axes), and that element has a body element as a child, user agents must instead apply the overflow-* values of the first such child element to the viewport. The element from which the value is propagated must then have a used overflow value of visible.

If visible is applied to the viewport, it must be interpreted as auto.

If clip is applied to the viewport, it must be interpreted as hidden.

3.5. Flow relative properties: the overflow-block and overflow-inline properties

The following properties are processed according to the same processing model as the Flow-Relative box model properties defined in CSS Logical Properties 1 §3 Flow-Relative Box Model Properties.

These properties correspond to the overflow-x and overflow-y properties. The mapping depends on the element’s writing-mode.

4. Limiting Visible Lines: the max-lines property

This property allows limiting the contents of a block container to the specified number of lines; remaining content is fragmented away and neither rendered nor measured. Specifically, if the value of max-lines is not none:

• The box becomes a fragmentation container that captures region breaks, if it is not already. [CSS-BREAK-3]
• A region break is forced after its Nth descendant in-flow line box, where N is the specified value of max-lines. The contents of descendants that are scroll containers or that are not block containers are skipped over while counting line boxes.

  If fewer than N line boxes exist, then max-lines introduces no region break.

• The position of the first forced region break (whether imposed by max-lines or by another mechanism, such as the break-before/break-after properties) is treated as the end of the fragmentation container, and the rest of the fragmented flow is laid out in the next fragmentation container in the fragmentation context.

  If there is no subsequent fragmentation container (which is the case if the box became a fragmentation container merely as a consequence of applying the max-lines property), the rest of the fragmented flow is discarded, similar to if it were display: none: it is neither rendered, nor measured as part of the box’s contents for the purpose of finding its min-content, max-content, or automatic block sizes, nor does allow user interaction. However, since intrinsic sizes are calculated across all fragmentation containers, this content is taken into account for the purpose of finding the box’s min-content and max-content inline sizes (see CSS Fragmentation 3 §5.1 Breaking into Varying-size Fragmentainers).

  Note: In the case of parallel fragmentation flows, content occuring after the fragmentation break in the box tree could still be rendered, if it is laid out above the position representing the end of this fragmentation container.

Only positive integers are accepted. Zero or negative integers are invalid and must cause the declaration to be ignored.

Note: The widows, orphans, and break-inside properties do not affect the position of the forced region break introduced by the max-lines property.

5. Indicating Block-Axis Overflow: the block-overflow property

This section is an unofficial draft, posted here for discussion. See issue.

This property allows inserting content into the last line box before a (forced or unforced) region break to indicate the continuity of truncated/interrupted content. It only affects line boxes contained directly by the block container itself, but as it inherits, will have an effect on descendants’ line boxes unless overridden. If the box contains no line box immediately preceding a region break, then this property has no effect.

Should this apply to other types of fragmentation breaks (e.g. pages, columns)?

The inserted content is called the block overflow ellipsis. Values have the following meanings:

clip

The rendering is unaffected.

ellipsis

Render an ellipsis character (U+2026)—or a more typographically-appropriate equivalent—as the block overflow ellipsis at the end of the affected line box. UAs should use the conventions of the content language, writing system, and writing mode to determine the most appropriate ellipsis string.

<string>

Render the specified string as the block overflow ellipsis at the end of the affected line box. The UA may truncate this string if it is absurdly long.

li {
  max-lines: 5;
  block-overflow: "… (continued on next page)";
}
strong {
  display: block;
  text-transform: uppercase;
}

<li><a href="cheese-is-milk">
  <strong>Cheese is Actually Made of Milk!</strong>
  Investigative reporters at the World Wide Web Press Corps
  have discovered the secret of cheese.
  Tracing through byzantine layers of bureacracy and shadow corporations,
  our crack team of journalists have traced the source of camembert.
</a></li>

+---------------------------------------+
| CHEESE IS ACTUALLY MADE OF MILK!      |
| Investigative reporters at the World  |
| Wide Web Press Corps have discovered  |
| the secret of cheese. Tracing through |
| byzantine…  (continued on next page)  |
+---------------------------------------+

When block-overflow is not clip, the block overflow ellipsis string is wrapped in an anonymous inline and placed at the end of the line box as a direct child of the block container’s root inline box, reducing the space in the line box available to the other contents of the line. This inline is assigned unicode-bidi: plaintext and is placed in the line box after the last soft wrap opportunity [CSS-TEXT-3] that would still allow the entire block overflow ellipsis to fit on the line. (This can result in the entire contents of the line box being replaced.) For this purpose, soft wrap opportunities added by overflow-wrap are ignored. Text alignment and justification occurs after placement, and measures the inserted block overflow ellipsis together with the rest of the line’s content.

If there is no next fragmentation container and thus the remainder of the content after the break would be discarded, then the UA may visually replace the contents of the line, as it does for text-overflow. If, however, there is a next fragmentation container that would receive subsequent content, then the content replaced by the block overflow ellipsis must be pushed to the next fragmentation container and the block overflow ellipsis inserted and laid out exactly as if it were part of the in-flow contents of the line. This can result in changes to layout within or impacted by the line. The means of breaking any resulting cycles is up to the UA.

If the block overflow ellipsis is too long to fit in the line, the result is undefined. (The UA may, for example, treat the block overflow ellipsis as an unbreakable string, or it may lay out the string across more than one line, replacing content in earlier lines as well.)

The block overflow ellipsis does not capture events: pointer events are dispatched to whatever is underneath or otherwise visually replaced by it.

It also has no effect on the intrinsic size of the box: its min-content and max-content sizes are calculated exactly as if block-overflow were clip.

Note: Future specifications may extend this feature, for example by providing an ::ellipsis pseudo-element to style the text, or by allowing the selection of a child element of the block to use as either an inline-level or block-level indicator (in which case, it can capture events).

6. Setting max-lines and block-overflow together: the line-clamp property

The line-clamp property is a shorthand for the max-lines and block-overflow properties.

none

Sets max-lines to none and block-overflow to clip.

<integer>

Sets max-lines to the specified <integer> and block-overflow to ellipsis.

For compatibility with legacy content, UAs that support line-clamp must also support -webkit-line-clamp as an alias.

7. Privacy and Security Considerations

This specification introduces no new privacy or security concerns.

Acknowledgments

Thanks especially to the feedback from Rossen Atanassov, Bert Bos, Tantek Çelik, John Daggett, Daniel Glazman, Vincent Hardy, Håkon Wium Lie, Peter Linss, Robert O’Callahan, Florian Rivoal, Alan Stearns, Steve Zilles, and all the rest of the www-style community.