Movatterモバイル変換

9 Visual formatting model

9.1Introduction to the visual formatting model

This chapter and the next describe thevisual formatting model: how useragents process thedocument treefor visualmedia.

In the visual formatting model, each element in the document treegenerates zero or more boxes according to theboxmodel. The layout of these boxes is governed by:

• box dimensions andtype.
• positioning scheme(normal flow, float, and absolute positioning).
• relationships between elementsin thedocument tree.
• external information (e.g., viewport size,intrinsic dimensions of images, etc.).

The properties defined in this chapter and the next apply to bothcontinuous media andpaged media.However, themeanings of themarginproperties vary when applied to paged media (see thepage model for details).

The visual formatting model does not specify all aspects offormatting (e.g., it does not specify a letter-spacing algorithm).Conforming user agents may behavedifferently for those formatting issues not covered by thisspecification.

9.1.1The viewport

User agents forcontinuous mediagenerally offer users aviewport (a window or otherviewing area on the screen) through which users consult adocument. User agents may change the document's layout when theviewport is resized (see theinitial containing block).

When the viewport is smaller than the area of the canvas on whichthe document is rendered, the user agent should offer a scrollingmechanism.There is at mostone viewport percanvas, but useragents may render to more than one canvas (i.e., provide differentviews of the same document).

9.1.2Containing blocks

In CSS 2.2, many box positions and sizes are calculated with respectto the edgesof a rectangular box called acontaining block. Ingeneral, generated boxes act as containing blocks for descendantboxes; we say that a box "establishes" the containing block for itsdescendants. The phrase "a box's containing block" means "thecontaining block in which the box lives," not the one it generates.

Each box is given a position with respect to its containing block,but it is not confined by this containing block; it mayoverflow.

Thedetails ofhow a containing block's dimensions are calculated are described inthenext chapter.

9.2Controlling box generation

The following sections describe the types of boxes that may begenerated in CSS 2.2. A box's type affects, in part, its behavior in thevisual formatting model. The'display' property, described below,specifies a box's type.

Certain values of the'display' property cause an element ofthe source document to generate aprincipalbox that contains descendant boxes and generatedcontent and is also the box involved in any positioning scheme. Someelements may generate additional boxes in addition to the principalbox: 'list-item' elements. These additional boxes are placed withrespect to the principal box.

9.2.1Block-level elements and block boxes

Block-level elements –those elements of the source document that are formatted visually asblocks (e.g., paragraphs) – are elements which generate ablock-level principal box. Values of the'display' property that make anelement block-level include: 'block', 'list-item', and 'table'.Block-levelboxes are boxes that participate in ablock formatting context.

In CSS 2.2, a block-level box is also a block container boxunless it is a table box or the principal box of a replaced element.Ablock container boxeither contains only block-level boxes or establishes aninline formatting context and thuscontains onlyinline-levelboxes. An element whose principal box is a block container box isablock containerelement. Values of the 'display' property which makea non-replaced element generate a block container include 'block','list-item' and 'inline-block'. Not all block container boxes areblock-level boxes: non-replaced inline blocks and non-replaced tablecells are block containers but are not block-level. Block-level boxesthat are also block containers are calledblock boxes.

The three terms "block-level box," "block container box," and"block box" are sometimes abbreviated as "block" where unambiguous.

9.2.1.1Anonymous block boxes

In a document like this:

<DIV>  Some text  <P>More text</DIV>

(and assuming the DIV and the P both have 'display: block'), theDIV appears to have both inline content and block content. To make iteasier to define the formatting, we assume that there is ananonymous block boxaround "Some text".

In other words: if a block container box (such as that generatedfor the DIV above) has a block-level box inside it (such as the Pabove), then we force it to haveonly block-level boxesinside it.

When an inline box contains an in-flow block-level box, the inline box(and its inline ancestors within the same line box) is broken aroundthe block-level box (and any block-level siblings that are consecutiveor separated only by collapsible whitespace and/or out-of-flowelements), splitting the inline box into two boxes (even if eitherside is empty), one on each side of the block-level box(es). The lineboxes before the break and after the break are enclosed in anonymous block boxes, and the block-level box becomes a sibling of those anonymous boxes. When such an inline box is affected by relative positioning, any resulting translation alsoaffects the block-level box contained in the inline box.

p    { display: inline }span { display: block }

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"><HEAD><TITLE>Anonymous text interrupted by a block</TITLE></HEAD><BODY><P>This is anonymous text before the SPAN.<SPAN>This is the content of SPAN.</SPAN>This is anonymous text after the SPAN.</P></BODY>

The properties of anonymous boxes are inherited from theenclosing non-anonymous box (e.g., in the example just below the subsection heading "Anonymous block boxes", the one for DIV). Non-inherited properties have their initial value. For example,the font of the anonymous box is inherited from the DIV, but themargins will be 0.

Properties set on elements that cause anonymous block boxes to be generated still apply to the boxes and content of that element. For example, if a border had been set on the P element in the above example, the border would be drawn around C1 (open at the end of the line) and C2 (open at the start of the line).

Some user agents have implemented borders on inlines containing blocks in other ways, e.g., by wrapping such nested blocks inside "anonymous line boxes" and thus drawing inline borders around such boxes. As CSS1 and CSS2 did not define this behavior, CSS1-only and CSS2-only user agents may implement this alternative model and still claim conformance to this part of CSS 2.2. This does not apply to UAs developed after this specification was released.

Anonymous block boxes are ignored when resolving percentage valuesthat would refer to it: the closest non-anonymous ancestor box is usedinstead. For example, if the child of the anonymous block box insidethe DIV above needs to know the height of its containing block toresolve a percentage height, then it will use the height of thecontaining block formed by the DIV, not of the anonymous block box.

9.2.2Inline-level elements and inline boxes

Inline-levelelements are those elements of the source document thatdo not form new blocks of content; the content is distributed in lines (e.g., emphasized pieces of textwithin a paragraph, inline images,etc.). The following values of the'display' property make an elementinline-level: 'inline', 'inline-table', and 'inline-block'. Inline-level elements generateinline-levelboxes, which are boxes that participate in an inlineformatting context.

Aninlinebox is one that is both inline-level and whosecontents participate in its containing inline formatting context. Anon-replaced element with a 'display' value of 'inline' generates aninline box.Inline-level boxes that are not inline boxes (such as replacedinline-level elements, inline-block elements, and inline-tableelements) are calledatomic inline-level boxes becausethey participate in their inline formatting context as a single opaquebox.

9.2.2.1Anonymous inline boxes

Any text that is directly contained inside a block container element (notinside an inline element) must be treated as an anonymous inlineelement.

In a document with HTML markup like this:

<p>Some <em>emphasized</em> text</p>

the<p> generates a block box, with several inline boxes insideit. The box for "emphasized" is an inline box generated by an inlineelement (<em>), but the other boxes ("Some" and "text") are inline boxes generated by a block-level element (<p>). The latter are calledanonymous inlineboxes, because they do not have an associated inline-level element.

Such anonymous inline boxes inherit inheritable properties fromtheir block parent box. Non-inherited properties have their initialvalue. In the example, the color of the anonymous inline boxes isinherited from the P, but the background is transparent.

White space content that would subsequently be collapsed away according to the'white-space' property does not generate any anonymous inline boxes.

If it is clear from the context which type of anonymous box ismeant, both anonymous inline boxes and anonymous block boxes aresimply called anonymous boxes in this specification.

There are more types of anonymous boxes that arise when formattingtables.

9.2.3Run-in boxes

[This section exists so that the section numbers are the same as inprevious drafts.'Display:run-in' is now defined in CSS level 3 (seeCSS basic box model).]

9.2.4The'display' property

The values of this property have the following meanings:

block

This value causes an element to generate a principal block box.

inline-block

This value causes an element to generate a principal inline-level blockcontainer.(The inside of an inline-block is formatted as a block box, and the element itself is formatted as an atomic inline-level box.)

inline

This value causes an element to generate one or more inline boxes.

list-item

This value causes an element (e.g., LI in HTML) to generate aprincipal block box and a marker box. For information aboutlists and examples of list formatting, please consult the section onlists.

none

Thisvalue causes an element to not appear in theformatting structure (i.e.,in visual media the element generates no boxes and has no effect onlayout). Descendant elements do not generate any boxes either; theelement and its content are removed from the formatting structureentirely. This behaviorcannot be overridden bysetting the'display' propertyon the descendants.

Please note that a display of 'none' does not create an invisiblebox; it creates no box at all. CSS includes mechanisms that enable anelement to generate boxes in the formatting structure that affectformatting but are not visible themselves. Please consult the sectiononvisibility for details.

table,inline-table,table-row-group,table-column,table-column-group,table-header-group,table-footer-group,table-row,table-cell, andtable-caption

These values cause an element to behave like a table element(subject to restrictions described in the chapter ontables).

The computed value is the same as the specified value, except forpositioned and floating elements (seeRelationships between 'display', 'position', and'float') and for the root element. For the root element, the computed value is changed as described in the section on therelationships between 'display', 'position', and 'float'.

Note that although theinitialvalue of'display' is'inline', rules in the user agent'sdefault style sheet mayoverride this value. See thesample style sheet for HTML 4 in theappendix.

p   { display: block }em  { display: inline }li  { display: list-item } img { display: none }      /* Do not display images */

9.3Positioning schemes

In CSS 2.2, a box may be laid out according to threepositioningschemes:

1. Normal flow. In CSS 2.2, normalflow includesblock formattingof block-level boxes,inline formattingof inline-level boxes, andrelative positioning ofblock-level and inline-level boxes.
2. Floats. In the float model,a box is first laid out according to the normal flow, then taken out of the flow and shiftedto the left or right as far as possible. Content mayflow along the side of a float.
3. Absolute positioning. In the absolute positioning model, a box is removed fromthe normal flow entirely (it has no impact on later siblings)and assigned a position with respect to a containing block.

An element is calledout offlow if it is floated, absolutely positioned, or is theroot element. An element is calledin-flow if it is not out-of-flow. Theflow of an elementA is the set consisting ofA and all in-flowelements whose nearest out-of-flow ancestor isA.

9.3.1Choosing a positioning scheme:'position' property

The'position' and'float' properties determine which of the CSS 2.2 positioning algorithms is used to calculate the position of a box.

The values of this property have the following meanings:

static

The box is a normal box, laid out according to thenormal flow. The'top','right','bottom',and'left'properties do not apply.

relative

The box's position is calculated according to thenormal flow (this is called the position innormal flow). Then the box is offsetrelative to its normal position. Whena box B is relatively positioned, the position of the following box iscalculated as though B were not offset. The effect of 'position:relative' on table-row-group, table-header-group, table-footer-group, table-row, table-column-group, table-column, table-cell, and table-caption elements is undefined.

absolute

The box's position (and possibly size) is specifiedwith the'top','right','bottom', and'left'properties.These properties specify offsets with respect to the box'scontaining block. Absolutelypositioned boxes are taken out of the normal flow. This meansthey have no impact on the layout of later siblings. Also,thoughabsolutely positioned boxes have margins, theydo notcollapsewith any other margins.

fixed

The box's position is calculated according to the 'absolute'model, but in addition, the box isfixed with respect to some reference. As with the 'absolute' model, the box's margins do not collapse with any other margins.In the case of handheld, projection, screen, tty, and tv media types, the box is fixed with respect to theviewport and does not move when scrolled. In the case of the print media type, the box is rendered on every page, and is fixed with respect to the page box, even if the page is seen through aviewport (in the case of a print-preview, for example). For other media types, the presentation is undefined. Authors may wish to specify 'fixed' in amedia-dependent way. For instance, an author may want a box to remainat the top of theviewport on the screen, butnot at the top of each printed page. The two specifications may beseparated by using an@mediarule, as in:

Example(s):

   @media screen {   h1#first { position: fixed } }@media print {   h1#first { position: static }}

UAs must not paginate the content of fixed boxes.Note that UAs may print invisible content in otherways. See"Content outside thepage box" in chapter 13.

User agents may treat position as 'static' on the root element.

9.3.2Box offsets:'top','right','bottom','left'

An element is said to bepositionedif its'position' property hasa value other than 'static'. Positioned elements generatepositioned boxes, laid out according to four properties:

This property specifies how far anabsolutely positioned box's topmargin edge is offset below the top edge of the box'scontaining block. For relativelypositioned boxes, the offset is with respect to the top edges of thebox itself (i.e., the box is given a position in the normal flow, thenoffset from that position according to these properties).

Like 'top', but specifies how far a box's right margin edge isoffset to the left of the right edge of the box'scontaining block. For relativelypositioned boxes, the offset is with respect to the right edge of thebox itself.

Like 'top', but specifies how far a box's bottom margin edge isoffset above the bottom of the box'scontaining block. For relativelypositioned boxes, the offset is with respect to the bottom edge of thebox itself.

Like 'top', but specifies how far a box's left margin edge isoffset to the right of the left edge of the box'scontaining block. For relativelypositioned boxes, the offset is with respect to the left edge of thebox itself.

The values for the four properties have the following meanings:

<length>

The offset is a fixed distance from the reference edge. Negative values are allowed.

<percentage>

The offset is a percentage of the containing block's width (for'left' or'right') or height (for'top' and'bottom'). Negative values are allowed.

auto

For non-replaced elements, the effect of this value depends on which of related properties have the value 'auto' aswell. See the sections on thewidthandheightofabsolutely positioned, non-replaced elements for details. For replaced elements, theeffect of this value depends only on the intrinsic dimensions of thereplaced content. See the sections on thewidth andheight of absolutelypositioned, replaced elements for details.

9.4Normal flow

Boxes in the normal flow belong to aformatting context, which in CSS 2.2may be table, block or inline. In future levels of CSS, other types offormatting context will be introduced.Block-level boxes participate in ablock formatting context.Inline-level boxes participate in aninline formatting context. Tableformatting contexts are described in thechapter on tables.

9.4.1Block formatting contexts

Floats, absolutely positioned elements, block containers (such asinline-blocks, table-cells, and table-captions) that are not blockboxes, and block boxes with 'overflow' other than 'visible'(except when that value has been propagated to the viewport) establishnew block formatting contexts for their contents.

In a block formatting context, boxes are laid out one after theother, vertically, beginning at the top of a containing block. Thevertical distance between two sibling boxes is determined by the'margin' properties. Vertical marginsbetween adjacent block-level boxes in a block formatting contextcollapse.

In a block formatting context, each box's left outer edge touches theleft edge of the containing block (for right-to-left formatting, rightedges touch). This is true even in the presence of floats (although abox'sline boxes may shrink due to the floats), unless the boxestablishes a new block formatting context (in which case the box itselfmay become narrower due tothe floats).

For information about page breaks in paged media, please consultthe section onallowedpage breaks.

9.4.2Inline formatting contexts

An inline formatting context is established by a block containerbox that contains no block-level boxes.In an inline formatting context, boxes are laid out horizontally,one after the other, beginning at the top of a containingblock. Horizontal margins, borders, and padding are respected betweenthese boxes. The boxes may be aligned vertically in different ways: theirbottoms or tops may be aligned, or the baselines of text within themmay be aligned. The rectangular area that contains the boxes that forma line is called aline box.

The width of a line box is determined by acontaining block and the presence of floats. The height of a linebox is determined by the rules given in the section online height calculations.

A line box is always tall enough for all of the boxes it contains. However, it may be taller than the tallest box it contains (if, for example, boxes are aligned so that baselines line up). When the height of a box B is less than the height of the line box containing it, the vertical alignment of B within the line box is determined by the'vertical-align' property.When several inline-level boxes cannot fit horizontally within a singleline box, they are distributed among two or more vertically-stackedline boxes. Thus, a paragraph is a vertical stack of line boxes. Lineboxes are stacked with no vertical separation (except as specifiedelsewhere) and they never overlap.

In general, the left edge of a line box touches the left edgeof its containing block and the right edge touches the right edge ofits containing block. However, floating boxes may come between thecontaining block edge and the line box edge. Thus, although lineboxes in the same inline formatting context generally have the samewidth (that of the containing block), they may vary in width ifavailable horizontal space is reduced due tofloats. Line boxes in the same inline formattingcontext generally vary in height (e.g., one line might contain a tallimage while the others contain only text).

When the total width of the inline-level boxes on a line is less than thewidth of the line box containing them, their horizontal distributionwithin the line box is determined by the'text-align' property. If thatproperty has the value 'justify', the user agent may stretch spacesand words in inline boxes (but not inline-table and inline-blockboxes) as well.

When an inline box exceeds the width of a line box, it is split into several boxes and these boxes are distributed across several line boxes. If an inline box cannot be split (e.g., if the inline box contains a single character, or language specific word breaking rules disallow a break within the inline box, or if the inline box is affected by a white-space value of nowrap or pre), then the inline box overflows the line box.

When an inline box is split, margins,borders, and padding have no visual effect where the split occurs (orat any split, when there are several).

Inline boxes may also be split into several boxeswithin thesame line box due tobidirectional textprocessing.

Line boxes are created as needed to holdinline-level content within an inline formatting context. Line boxesthat contain no text, nopreserved white space, no inlineelements with non-zero margins, padding, or borders, and no otherin-flow content (such as images, inlineblocks or inline tables), and do not end with a preserved newline mustbe treated as zero-height line boxes for the purposes of determiningthe positions of any elements inside of them, and must be treated asnot existing for any other purpose.

<P>Several <EM>emphasized words</EM> appear<STRONG>in this</STRONG> sentence, dear.</P>

 Severalemphasized words appearin this sentence, dear.

Severalemphasized words appearin this sentence, dear.

Severalemphasizedwords appearin this sentence, dear.

In the previous example, the EM box was split into two EM boxes(call them "split1" and "split2"). Margins, borders,padding, or text decorations have no visible effect after split1 orbefore split2.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"><HTML>  <HEAD>    <TITLE>Example of inline flow on several lines</TITLE>    <STYLE type="text/css">      EM {        padding: 2px;         margin: 1em;        border-width: medium;        border-style: dashed;        line-height: 2.4em;      }    </STYLE>  </HEAD>  <BODY>    <P>Several <EM>emphasized words</EM> appear here.</P>  </BODY></HTML>

9.4.3Relative positioning

Once a box has been laid out according to thenormal flow or floated, it may be shifted relative tothis position. This is calledrelative positioning. Offsetting a box(B1) in this way has no effect on the box (B2) that follows: B2 isgiven a position as if B1 were not offset and B2 is not re-positionedafter B1's offset is applied. This implies that relative positioningmay cause boxes to overlap.However, if relative positioning causes an 'overflow:auto' or'overflow:scroll' box to haveoverflow, the UA must allow the user to access this content (at its offsetposition), which, through the creation of scrollbars, may affect layout.

A relatively positioned box keeps its normal flow size, includingline breaks and the space originally reserved for it. The section oncontaining blocks explains when arelatively positioned box establishes a new containing block.

For relatively positioned elements, 'left' and 'right' move thebox(es) horizontally, without changing their size. 'Left' moves theboxes to the right, and 'right' moves them to the left. Since boxesare not split or stretched as a result of 'left' or 'right', theused values are always: left = -right.

If both 'left' and 'right' are 'auto' (their initial values), theused values are '0' (i.e., the boxes stay in their originalposition).

If 'left' is 'auto', its used value is minus the value of 'right'(i.e., the boxes move to the left by the value of 'right').

If 'right' is specified as 'auto', its used value is minus thevalue of 'left'.

If neither 'left' nor 'right' is 'auto', the position isover-constrained, and one of them has to be ignored. If the 'direction' property of the containing block is 'ltr', the value of 'left' wins and 'right'becomes -'left'. If 'direction' of the containing block is 'rtl', 'right' wins and 'left' is ignored.

div.a8 { position: relative; direction: ltr; left: -1em; right: auto }div.a8 { position: relative; direction: ltr; left: auto; right: 1em }div.a8 { position: relative; direction: ltr; left: -1em; right: 5em }

The 'top' and 'bottom' properties move relatively positionedelement(s) up or down without changing their size. 'Top' moves theboxes down, and 'bottom' moves them up. Since boxesare not split or stretched as a result of 'top' or 'bottom', theused values are always: top = -bottom.If both are 'auto', their used values are both '0'. If one of them is'auto', it becomes the negative of the other. If neither is 'auto','bottom' is ignored (i.e., the used value of 'bottom' will beminus the value of 'top').

Note. Dynamic movement of relatively positioned boxes can produceanimation effects in scripting environments (see also the'visibility' property). Although relative positioning may be used as a form of superscripting and subscripting, the line height is not automatically adjusted to take the positioning into consideration. See the description ofline height calculations for moreinformation.

Examples of relative positioning are provided in the sectioncomparing normal flow, floats, and absolutepositioning.

9.5Floats

A float is a box that is shifted to the left or right on thecurrent line. The most interesting characteristic of a float (or"floated" or "floating" box) is that content may flow along its side(or be prohibited from doing so by the'clear' property). Content flows downthe right side of a left-floated box and down the left side of aright-floated box. The following is an introduction to floatpositioning and content flow; the exactrules governing float behavior are given inthe description of the'float'property.

A floated box isshifted to the left or right until its outer edge touches thecontaining block edge or the outer edge of another float. If there is a line box, the outer top of the floated box is aligned with the top of the current line box.

If there is not enough horizontal room for thefloat, it is shifted downward until either it fits or there are nomore floats present.

Since a float is not in the flow, non-positioned block boxescreated before and after the float box flow vertically as if the floatdid not exist. However,the current and subsequentline boxes created next to the float areshortenedas necessaryto make room for the margin box of the float.

A line box is next to a float when there exists a vertical positionthat satisfies all of these four conditions: (a) at or below the topof the line box, (b) at or above the bottom of the line box, (c) belowthe top margin edge of the float, and (d) above the bottom margin edgeof the float.

Note: this means that floats with zero outer height ornegative outer height do not shorten line boxes.

If a shortened line box is too small to contain any content, thenthe line box is shifted downward (and its width recomputed) untileither some content fits or there are no more floats present.Any content in the current line before a floated box is reflowed in the same line on the other side of the float.In other words, if inline-level boxes are placed on the line before a left float is encountered that fits in the remaining line box space, the left float is placed on that line, aligned with the top of the line box, and then the inline-level boxes already on the line are moved accordingly to the right of the float (the right being the other side of the left float) and vice versa for rtl and right floats.

The border box of a table, a block-level replaced element, or an element in the normal flow that establishes a newblock formatting context (such as an element with 'overflow' other than 'visible')must not overlap the margin box of any floats in the same blockformatting context asthe element itself. If necessary, implementations should clear thesaid element by placing it below any preceding floats, but may placeit adjacent to such floats if there is sufficient space.They may even make the border box of said element narrower thandefined bysection 10.3.3.CSS2 does not define when a UA may put said element next to the floator by how much said element may become narrower.

p { width: 10em; border: solid aqua; }span { float: left; width: 5em; height: 5em; border: solid blue; }...<p>  <span> </span>  Supercalifragilisticexpialidocious</p>

Several floats may be adjacent, and this model also applies toadjacent floats in the same line.

img.icon {   float: left;  margin-left: 0;}

  <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"><HTML>  <HEAD>    <TITLE>Float example</TITLE>    <STYLE type="text/css">      IMG { float: left }      BODY, P, IMG { margin: 2em }    </STYLE>  </HEAD>  <BODY>    <P><IMG src=img.png alt="This image will illustrate floats">       Some sample text that has no other...  </BODY></HTML>

<BODY>  <P>Some sample text   <IMG src=img.png alt="This image will illustrate floats">           that has no other...</BODY>

As stated insection 8.3.1, the margins of floating boxes nevercollapse with margins ofadjacent boxes. Thus, in the previous example, vertical margins do notcollapse between the P boxand the floated IMG box.

The contents of floats are stacked as if floats generated new stacking contexts, except that any positioned elements and elementsthat actually create newstacking contexts take part in the float's parent stacking context. A float can overlap other boxes in the normal flow (e.g., when a normal flow box next to a float has negative margins). When this happens, floats are rendered in front of non-positioned in-flow blocks, but behind in-flow inlines.

The following example illustrates the use of the'clear' property to prevent contentfrom flowing next to a float.

p { clear: left }

9.5.1Positioning the float: the'float' property

This property specifies whether a box should float to the left,right, or not at all. It may be set for any element, but only applies to elements that generate boxes that are notabsolutely positioned. The values of this property havethe following meanings:

left

The element generates ablock box that isfloated to the left. Content flows on the right side of the box,starting at the top (subject to the'clear' property).

right

Similar to 'left', except the box is floated to the right, and content flows on the left side of the box, starting at the top.

none

The box is not floated.

User agents may treat float as 'none' on the root element.

Here are the precise rules thatgovern the behavior of floats:

1. The leftouter edge of aleft-floating box may not be to the left of the left edge of itscontaining block. Ananalogous rule holds for right-floating elements.
2. If the current box is left-floating, and there are any left-floating boxes generated by elements earlier in the source document,then for each such earlier box, either the leftouter edge of the current box must beto the right of the rightouter edgeof the earlier box, or its top must be lower than the bottom of theearlier box. Analogous rules hold for right-floating boxes.
3. The rightouter edge of aleft-floating box may not be to the right of the leftouter edge of any right-floatingbox that is next to it. Analogous rules hold forright-floating elements.
4. A floating box'souter topmay not be higher than the top of itscontaining block.When the float occurs between two collapsing margins, thefloat is positioned as if it had an otherwise emptyanonymous block parent taking part inthe flow. The position of such a parent is defined bythe rules in the section on margincollapsing.
5. Theouter top of a floating boxmay not be higher than the outer top of anyblock orfloated box generated by an elementearlier in the source document.
6. Theouter top of an element'sfloating box may not be higher than the top of anyline-box containing a boxgenerated by an element earlier in the source document.
7. A left-floating box that has another left-floating box to its leftmay not have its right outer edge to the right of its containingblock's right edge. (Loosely: a left float may not stick out at theright edge, unless it is already as far to the left as possible.) Ananalogous rule holds for right-floating elements.
8. A floating box must be placed as high as possible.
9. A left-floating box must be put as far to the left aspossible, a right-floating box as far to the right as possible. Ahigher position is preferred over one that is further to theleft/right.

But in CSS 2.2, if, within the block formatting context, thereis an in-flow negative vertical margin such that the float's positionis above the position it would be at were all such negative marginsset to zero, the position of the float is undefined.

References to other elements in these rules refer only to other elements in the sameblock formatting context as the float.

<P>a<SPAN>b</SPAN></P>

9.5.2Controlling flow next to floats:the'clear' property

This property indicates which sides of an element's box(es) maynot be adjacent to an earlier floating box. The 'clear'property does not consider floats inside the element itself or inotherblock formattingcontexts.

Values have the following meanings when applied to non-floatingblock-level boxes:

left

Requires that the top border edge of the box be below the bottomouter edge of any left-floating boxes that resulted from elementsearlier in the source document.

right

Requires that the top border edge of the box be below the bottomouter edge of any right-floating boxes that resulted from elementsearlier in the source document.

both

Requires that the top border edge of the box be below the bottomouter edge of any right-floating and left-floating boxes that resultedfrom elements earlier in the source document.

none

No constraint on the box's position with respect to floats.

Values other than 'none' potentially introduceclearance.Clearance inhibits margin collapsingand acts as spacing above the margin-top of an element. It is used topush the element vertically past the float.

Computing the clearance of an element on which 'clear' is set isdone by first determining the hypothetical position of the element'stop border edge. This position iswhere the actual top border edge would have been if the element's'clear' property had been 'none'.

If this hypothetical position of the element's top border edge isnot past the relevant floats, then clearance is introduced, andmargins collapse according to the rules in 8.3.1.

Then the amount of clearance is set to the greater of:

1. The amount necessary to place the border edge of the block even with the bottom outer edge of the lowest float that is to be cleared.
2. The amount necessary to place the top border edge of the block at its hypothetical position.

Alternatively, clearance is set exactly to the amount necessary toplace the border edge of the block even with the bottom outer edge ofthe lowest float that is to be cleared.

Note: Both behaviors are allowedpending evaluation of their compatibility with existing Web content. Afuture CSS specification will require either one or the other.

Note: The clearance can be negative or zero.

<p>  First paragraph.<p>  Floating paragraph.<p>  Last paragraph.

When the property is set on floating elements, it results in amodification of therules forpositioning the float. An extra constraint (#10) is added:

• The topouter edge of the float must be below the bottom outeredge of all earlier left-floating boxes (in the case of 'clear:left'), or all earlier right-floating boxes (in the case of 'clear:right'), or both ('clear: both').

9.6Absolute positioning

In the absolute positioning model, a box is explicitly offset withrespect to its containing block. It is removed from the normal flowentirely (it has no impact on later siblings). An absolutelypositioned box establishes a new containing block for normal flowchildren and absolutely (but not fixed) positioned descendants. However, the contents of anabsolutely positioned element do not flow around any other boxes. Theymay obscure the contents of another box (or be obscured themselves), depending on thestack levels of the overlapping boxes.

References in this specification to anabsolutely positionedelement (or its box) imply that the element's'position' property has the value'absolute' or 'fixed'.

9.6.1Fixed positioning

Fixed positioning is a subcategory of absolute positioning. Theonly difference is that for a fixed positioned box, the containingblock is established by theviewport. Forcontinuous media, fixedboxes do not move when the document is scrolled. In this respect, theyare similar tofixedbackground images. Forpaged media, boxeswith fixed positions are repeated on every page. This is useful forplacing, for instance, a signature at the bottom of each page.Boxes with fixed position that are larger than the page area areclipped. Parts of the fixed position box that are not visible in theinitial containing block will not print.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"><HTML>  <HEAD>    <TITLE>A frame document with CSS</TITLE>    <STYLE type="text/css" media="screen">      BODY { height: 8.5in } /* Required for percentage heights below */      #header {        position: fixed;        width: 100%;        height: 15%;        top: 0;        right: 0;        bottom: auto;        left: 0;      }      #sidebar {        position: fixed;        width: 10em;        height: auto;        top: 15%;        right: auto;        bottom: 100px;        left: 0;      }      #main {        position: fixed;        width: auto;        height: auto;        top: 15%;        right: 0;        bottom: 100px;        left: 10em;      }      #footer {        position: fixed;        width: 100%;        height: 100px;        top: auto;        right: 0;        bottom: 0;        left: 0;      }    </STYLE>  </HEAD>  <BODY>    <DIV> ...  </DIV>    <DIV> ...  </DIV>    <DIV> ...  </DIV>    <DIV> ...  </DIV>  </BODY></HTML>

9.7Relationships between 'display', 'position',and 'float'

The three properties that affect box generation and layout —'display','position', and'float' — interact as follows:

1. If'display'has the value 'none', then'position' and'float' do not apply. In this case, the element generates no box.
2. Otherwise, if'position'has the value 'absolute' or 'fixed', the box is absolutely positioned, the computedvalue of'float' is 'none', and display is set according to the table below. The position of the box will be determined by the'top','right','bottom' and'left' properties and the box's containing block.
3. Otherwise, if 'float' has a value other than 'none', the box isfloated and 'display' is set according to the table below.
4. Otherwise, if the element is the root element, 'display' is set according to the table below, except that it isundefined in CSS 2.2 whether a specified value of 'list-item'becomes a computed value of 'block' or 'list-item'.
5. Otherwise, the remaining'display' property values applyas specified.

9.8Comparison of normal flow, floats, and absolute positioning

To illustrate the differences between normal flow, relativepositioning, floats, and absolute positioning, we provide a series ofexamples based on the following HTML:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"><HTML>  <HEAD>    <TITLE>Comparison of positioning schemes</TITLE>  </HEAD>  <BODY>    <P>Beginning of body contents.      <SPAN> Start of outer contents.      <SPAN> Inner contents.</SPAN>      End of outer contents.</SPAN>      End of body contents.    </P>  </BODY></HTML>

In this document, we assume the following rules:

body { display: block; font-size:12px; line-height: 200%;        width: 400px; height: 400px }p    { display: block }span { display: inline }

The final positions of boxes generated by theouter andinner elements vary in each example. In each illustration,the numbers to the left of the illustration indicate thenormal flow position of the double-spaced (forclarity) lines.

Note. The diagrams in this section are illustrative and not to scale. They are meant to highlight the differences between the various positioning schemes in CSS 2.2, and are not intended to be reference renderings of the examples given.

9.8.1Normal flow

Consider the following CSS declarations forouter andinner that do not alter thenormalflow of boxes:

#outer { color: red }#inner { color: blue }

The P element contains all inline content:anonymous inline text and two SPANelements. Therefore, all of the content will be laid outin an inline formatting context, within a containing blockestablished by the P element, producing something like:

9.8.2Relative positioning

To see the effect ofrelativepositioning, we specify:

#outer { position: relative; top: -12px; color: red }#inner { position: relative; top: 12px; color: blue }

Text flows normally up to theouter element. Theouter text is then flowed into its normal flow position anddimensions at the end of line 1. Then, the inline boxes containing thetext (distributed over three lines) are shifted as a unit by '-12px'(upwards).

The contents ofinner, as a child ofouter, wouldnormally flow immediately after the words "of outer contents" (on line1.5). However, theinner contents are themselves offsetrelative to theouter contents by '12px' (downwards), back totheir original position on line 2.

Note that the content followingouter is not affected by therelative positioning ofouter.

Note also that had the offset ofouter been '-24px', thetext ofouter and the body text would have overlapped.

9.8.3Floating a box

Now consider the effect offloating theinner element's text to the right by means of the followingrules:

#outer { color: red }#inner { float: right; width: 130px; color: blue }

Text flows normally up to theinner box, which is pulledout of the flow and floated to the right margin (its'width' has been assigned explicitly).Line boxes to the left of the float are shortened, and the document's remaining text flows into them.

To show the effect of the'clear' property, we add asiblingelement to the example:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"><HTML>  <HEAD>    <TITLE>Comparison of positioning schemes II</TITLE>  </HEAD>  <BODY>    <P>Beginning of body contents.      <SPAN id=outer> Start of outer contents.      <SPAN id=inner> Inner contents.</SPAN>      <SPAN id=sibling> Sibling contents.</SPAN>      End of outer contents.</SPAN>      End of body contents.    </P>  </BODY></HTML>

The following rules:

#inner { float: right; width: 130px; color: blue }#sibling { color: red }

cause theinner box to float to the right as before and thedocument's remaining text to flow into the vacated space:

However, if the'clear'property on thesibling element is set to 'right' (i.e., thegeneratedsibling box will not accept a position next tofloating boxes to its right), thesibling content begins toflow below the float:

#inner { float: right; width: 130px; color: blue }#sibling { clear: right; color: red }

9.8.4Absolute positioning

Finally, we consider the effect ofabsolute positioning.Consider the following CSS declarations forouter andinner:

#outer {     position: absolute;     top: 200px; left: 200px;     width: 200px;     color: red;}#inner { color: blue }

which cause the top of theouter box to be positioned withrespect to its containing block. The containing block for a positionedbox is established by the nearest positioned ancestor (or, if noneexists, theinitial containingblock, as in our example). The top side of theouter boxis '200px' below the top of the containing block and the left side is'200px' from the left side. The child box ofouter is flowednormally with respect to its parent.

The following example shows an absolutely positioned box that is achild of a relatively positioned box. Although the parentouter box is not actually offset, setting its'position' property to 'relative'means that its box may serve as the containing block for positioneddescendants. Since theouter box is an inline box that issplit across several lines, the first inline box's top and left edges(depicted by thick dashed lines in the illustration below)serve as references for'top' and'left' offsets.

#outer {   position: relative;   color: red }#inner {   position: absolute;   top: 200px; left: -100px;   height: 130px; width: 130px;   color: blue;}

This results in something like the following:

If we do not position theouter box:

#outer { color: red }#inner {  position: absolute;   top: 200px; left: -100px;   height: 130px; width: 130px;   color: blue;}

the containing block forinner becomes theinitial containing block (in ourexample). The following illustration shows where theinnerbox would end up in this case.

<P style="position: relative; margin-right: 10px; left: 10px;">I used two red hyphens to serve as a change bar. Theywill "float" to the left of the line containing THIS<SPAN style="position: absolute; top: auto; left: -1em; color: red;">--</SPAN>word.</P>

9.9Layered presentation

9.9.1Specifying the stack level: the'z-index' property

For a positioned box, the'z-index' property specifies:

1. The stack level of the box in the current stacking context.
2. Whether the box establishes a stacking context.

Values have the following meanings:

<integer>

This integer is the stack level of the generated box in the current stacking context. The box also establishes a new stacking context.

auto

The stack level of the generated box in the current stacking context is 0. If the box has 'position: fixed' or if it is the root, it also establishes a new stacking context.

In this section, the expression "in front of" means closer to the user as the user faces the screen.

In CSS 2.2, each box has a position in three dimensions. In additionto their horizontal and vertical positions, boxes lie along a "z-axis"and are formatted one on top of the other. Z-axis positions areparticularly relevant when boxes overlap visually. This sectiondiscusses how boxes may be positioned along the z-axis.

The order in which the rendering tree is painted onto the canvas is described in terms of stacking contexts. Stacking contexts can contain further stacking contexts. A stacking context is atomic from the point of view of its parent stacking context; boxes in other stacking contexts may not come between any of its boxes.

Each box belongs to onestacking context. Each positioned box in agiven stacking context has an integerstacklevel, which is its position on the z-axis relativeother stack levels within the same stacking context. Boxes withgreater stack levels are always formattedin front of boxes with lower stack levels. Boxes may have negativestack levels. Boxes with the same stack level in a stacking contextare stacked back-to-front according to document tree order.

The root element forms the root stacking context. Other stacking contexts are generated by any positioned element (including relatively positioned elements) having a computed value of 'z-index' other than 'auto'. Stacking contexts are not necessarily related to containing blocks. In future levels of CSS, other properties may introduce stacking contexts, for example 'opacity'[CSS3COLOR].

Within each stacking context, the following layers are painted inback-to-front order:

1. the background and borders of the element forming the stacking context.
2. the child stacking contexts with negative stack levels (most negative first).
3. the in-flow, non-inline-level, non-positioned descendants.
4. the non-positioned floats.
5. the in-flow, inline-level, non-positioned descendants, including inline tables and inline blocks.
6. the child stacking contexts with stack level 0 and the positioned descendants with stack level 0.
7. the child stacking contexts with positive stack levels (least positive first).

Within each stacking context, positioned elements with stack level0 (in layer 6), non-positioned floats (layer 4), inlineblocks (layer 5), and inline tables (layer 5), are paintedas if those elements themselves generated new stacking contexts,except that their positioned descendants and any would-be childstacking contexts take part in the current stacking context.

This painting order is applied recursively to each stackingcontext. This description of stacking context painting orderconstitutes an overview of the detailed normative definition inAppendix E.

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN"><HTML>  <HEAD>    <TITLE>Z-order positioning</TITLE>    <STYLE type="text/css">      .pile {         position: absolute;         left: 2in;         top: 2in;         width: 3in;         height: 3in;       }    </STYLE>  </HEAD>  <BODY>    <P>      <IMG            src="butterfly.png" alt="A butterfly image"          >    <DIV         >      This text will overlay the butterfly image.    </DIV>    <DIV>      This text will be beneath everything.    </DIV>    <DIV         >      This text will underlay text1, but overlay the butterfly image    </DIV>  </BODY></HTML>

This example demonstrates the notion oftransparency. The default behavior of the background is to allow boxes behind it to be visible. In the example, each box transparently overlays the boxes below it. Thisbehavior can be overridden by using one of the existingbackground properties.

9.10Text direction:the'direction'and'unicode-bidi'properties

Conforming user agents that donot support bidirectional text may ignore the'direction' and'unicode-bidi' propertiesdescribed in this section. This exception includes UAs that renderright-to-left characters simply because a font on the system contains thembut do not support the concept of right-to-left text direction.

The characters in certain scripts are written from right toleft. In some documents, in particular those written with the Arabicor Hebrew script, and in some mixed-language contexts, text in asingle (visually displayed) block may appear with mixeddirectionality. This phenomenon is calledbidirectionality, or"bidi" for short.

The Unicode standard ([UNICODE],[UAX9]) defines a complexalgorithm for determining the proper directionality of text. Thealgorithm consists of an implicit part based on character properties,as well as explicit controls for embeddings and overrides. CSS 2.2 relieson this algorithm to achieve proper bidirectional rendering. The'direction' and'unicode-bidi' properties allowauthors to specify how the elements and attributes of a documentlanguage map to this algorithm.

User agents that support bidirectional text must apply the Unicodebidirectional algorithm to every sequence of inline-level boxes uninterruptedby a forced (bidiclass B) break or block boundary. This sequence forms the"paragraph" unit in the bidirectional algorithm. The paragraph embeddinglevel is set according to the value of the'direction' property of the containingblock rather than by the heuristic given in steps P2 and P3 of the Unicodealgorithm.

Because the directionality of a text depends on the structure andsemantics of the document language, these properties should in mostcases be used only by designers of document type descriptions (DTDs),or authors of special documents. If a default style sheet specifiesthese properties, authors and users should not specify rules tooverride them.

The HTML 4 specification ([HTML4], section 8.2) definesbidirectionality behavior for HTML elements. The style sheetrules that would achieve the bidi behavior specified in[HTML4] aregiven inthe sample style sheet. TheHTML 4 specification also contains more information onbidirectionality issues.

This property specifies the base writing direction of blocks andthe direction of embeddings and overrides (see'unicode-bidi') for the Unicodebidirectional algorithm. In addition, it specifies such things as thedirection oftable column layout, the direction ofhorizontaloverflow, theposition of an incomplete last line in a block in case of 'text-align:justify'.

Values for this property have the following meanings:

ltr

Left-to-right direction.

rtl

Right-to-left direction.

For the'direction'property to affect reordering in inline elements, the'unicode-bidi' property's valuemust be 'embed' or 'override'.

Values for this property have the following meanings:

normal

The element does not open an additional level of embedding withrespect to the bidirectional algorithm. For inline elements,implicit reordering works across element boundaries.

embed

If the element is inline, this valueopens an additional level of embedding with respect to thebidirectional algorithm. The direction of this embedding level isgiven by the'direction'property. Inside the element, reordering is done implicitly. Thiscorresponds to adding a LRE (U+202A; for 'direction: ltr') or RLE(U+202B; for 'direction: rtl') at the start of the element and a PDF(U+202C) at the end of the element.

bidi-override

For inline elements this creates an override.For block container elements this creates an override for inline-level descendants not within another block containerelement.This means that inside the element, reordering is strictly in sequenceaccording to the'direction'property; the implicit part of the bidirectional algorithm isignored. This corresponds to adding a LRO (U+202D; for 'direction:ltr') or RLO (U+202E; for 'direction: rtl') at the start of theelement or at the start of each anonymous child block box, if any, anda PDF (U+202C) at the end of the element.

The final order of characters in each block container is thesame as if the bidi control codes had been added as described above,markup had been stripped, and the resulting character sequence hadbeen passed to an implementation of the Unicode bidirectionalalgorithm for plain text that produced the same line-breaks as thestyled text.In this process, replaced elements with 'display: inline'are treated asneutral characters, unless their'unicode-bidi' property has avalue other than 'normal', in which case they are treated as strongcharacters in the'direction'specified for the element.All other atomic inline-level boxes are treated as neutral charactersalways.

Please note that in order to be able to flow inline boxes in auniform direction (either entirely left-to-right or entirelyright-to-left), more inline boxes (including anonymous inline boxes)may have to be created, and some inline boxes may have to be split upand reordered before flowing.

Because the Unicode algorithm has a limit of61 levels ofembedding, care should be taken not to use'unicode-bidi' with a value otherthan 'normal' unless appropriate. In particular, a value of 'inherit'should be used with extreme caution. However, for elements that are,in general, intended to be displayed as blocks, a setting of'unicode-bidi: embed' is preferred to keep the element together incase display is changed to inline (see example below).

The following example shows an XML document with bidirectionaltext. It illustrates an important design principle:DTD designers should take bidiinto account both in the language proper (elements and attributes) andin any accompanying style sheets. The style sheets should be designedso that bidi rules are separate from other style rules. The bidi rulesshould not be overridden by other style sheets so that the documentlanguage's or DTD's bidi behavior is preserved.

<HEBREW>  <PAR>HEBREW1 HEBREW2 english3 HEBREW4 HEBREW5</PAR>  <PAR>HEBREW6 <EMPH>HEBREW7</EMPH> HEBREW8</PAR></HEBREW><ENGLISH>  <PAR>english9 english10 english11 HEBREW12 HEBREW13</PAR>  <PAR>english14 english15 english16</PAR>  <PAR>english17 <HE-QUO>HEBREW18 english19 HEBREW20</HE-QUO></PAR></ENGLISH>

/* Rules for bidi */HEBREW, HE-QUO  {direction: rtl; unicode-bidi: embed}ENGLISH         {direction: ltr; unicode-bidi: embed} /* Rules for presentation */HEBREW, ENGLISH, PAR  {display: block}EMPH                  {font-weight: bold}

               5WERBEH 4WERBEH english3 2WERBEH 1WERBEH                                8WERBEH7WERBEH 6WERBEHenglish9 english10 english11 13WERBEH 12WERBEHenglish14 english15 english16english17 20WERBEH english19 18WERBEH

       2WERBEH 1WERBEH  -EH 4WERBEH english3                 5WERB   -EH7WERBEH 6WERBEH                 8WERBenglish9 english10 en-glish11 12WERBEH13WERBEHenglish14 english15english16english17 18WERBEH20WERBEH english19