Extensible Stylesheet Language (XSL)

2.4.1 Root Node

The root node is the root of the tree. It does not occur anywhere else in the tree. It has a single child which is the element node for the document element of the document.

2.4.2 Element Nodes

There is an element node for every element in the document. An element has an expanded name consisting of a local name and a possibly null URI (see [W3C XML Names]); the URI will be null if the element type name has no prefix and there is no default namespace in scope.

An element node also has a namespace prefix map that specifies the namespace URI for each namespace prefix that is in scope for the element. The semantics of a document type may treat parts of attribute values or data content as namespace prefixes. The namespace prefix map ensures that the semantics can be preserved when the tree is written out as XML. When writing an element node out as XML, an XSL processor must add sufficient namespace-declaring attributes to the start-tag to ensure that all prefixes in the element node's namespace prefix map are correctly declared.

The children of an element node are the element nodes and characters for its content. Entity references to both internal and external entities are expanded. Character references are resolved.

The descendants of an element node are the character children, the element node children, and the descendants of the element node children.

The set of all element nodes in a document can be ordered according to the order of the start-tags of the elements in the document; this is known as document order.

<xsl:id attribute="name"/>

2.4.3 Attribute Nodes

Each element node has an associated set of attribute nodes. A defaulted attribute is treated the same as a specified attribute. If an attribute was declared for the element type, but the default was declared as #IMPLIED, and the attribute was not specified on the element, then the element's attribute set does not contain a node for the attribute.

An attribute node has an expanded name and has a string value. The expanded name consists of a local name and a possibly null URI (see [W3C XML Names]); the URI will be null if the specified attribute name did not have a prefix. The value is the normalized value as specified by the XML Recommendation [W3C XML]. An attribute value whose value is of zero length is not treated specially.

There are no attribute nodes for attributes that declare namespaces (see [W3C XML Names]).

2.4.4 Character Data

Each character within a CDATA section is treated as character data. Thus <![CDATA[<]]> in the source document will treated the same as <. Characters inside comments or processing instructions are not character data. Line-endings in external entities are normalized to #xA as specified in the XML Recommendation [W3C XML].

2.4.5 Whitespace Stripping

After the tree has been constructed, but before it is otherwise processed by XSL, some whitespace characters may be stripped. The stripping process takes as input a set of element types for which whitespace must be preserved. The stripping process is applied to both stylesheets and source documents, but the set of whitespace-preserving element types is determined differently for stylesheets and for source documents.

A character object is preserved if any of the following apply:

• The element type of the parent of the character is in the set of whitespace-preserving element types.

• It is part of a chunk that contains at least one non-whitespace character. As in XML, a whitespace character is #x20, #x9, #xD or #xA. A chunk of characters is a maximal sequence of sibling characters without any intervening elements.

• An ancestor element of the character has an xml:space attribute with a value of preserve, and no closer ancestor element has xml:space with a value of default.

Otherwise the character object is stripped.

The xml:space attributes are not stripped from the tree.

For stylesheets, the set of whitespace-preserving element types consists of just xsl:text.

For source documents, the set of whitespace-preserving element types is determined using the stylesheet as follows:

• If the xsl:stylesheet element specifies a default-space attribute with a value of strip, then the set is initially empty. Otherwise the set initially contains all element types that occur in the document.

• The xsl:strip-space element causes an element type to be removed from the set of whitespace-preserving element types. The element attribute gives the name of the element type.

• The xsl:preserve-space element causes an element type to be added to the set whitespace-preserving element types. The element attribute gives the name of the element type.

The xsl:stylesheet element can include an indent-result attribute with values yes or no. If the stylesheet specifies indent-result="yes", then the XSL processor may add whitespace to the result tree (possibly based on whitespace stripped from either the source document or the stylesheet) in order to indent the result nicely; if indent-result="no", it must not add any whitespace to the result. When adding whitespace with indent-result="yes", the XSL processor can use any algorithm provided that the result is the same as the result with indent-result="no" after whitespace is stripped from both using the process described with the set of whitespace-preserving element types consisting of just xsl:text.

2.5.1 Conflict Resolution for Template Rules

It is possible for a source node to match more than one template rule. The template rule to be used is determined as follows:

1. First, all matching template rules that are less important than the most important matching template rule or rules are eliminated from consideration.

2. Next, all matching template rules that are less specific (as defined in Section 2.6.11: Specificity) than the most specific matching template rule or rules are eliminated from consideration.

3. Next, all matching template rules that have a lower priority than the matching template rule or rules with the highest priority are eliminated from consideration. The priority of a rule is specified by the priority attribute on the rule. The value of this must be an integer (positive or negative). The default priority is 0. The integer must not be greater than 2147483647 nor less than -2147483648.

It is an error if this leaves more than one matching template rule. An XSL processor may signal the error; if it does not signal the error, it must recover by choosing from amongst the matching template rules that are left the one that occurs last in the stylesheet.

2.5.2 Built-in Template Rule

There is a built-in template rule to allow recursive processing to continue in the absence of a successful pattern match by an explicit rule in the stylesheet. This rule applies to both element nodes and the root node. The following shows the equivalent of the built-in template rule:

<xsl:template match="*|/">
  <xsl:process-children/>
</xsl:template>

The built-in template rule is treated as if it were imported implicitly before the stylesheet and so is considered less important than all other template rules. Thus the author can override the built-in rule by including an explicit rule with match="*|/".

2.6.1 Alternative Patterns

A pattern may consist of a set of patterns representing ancestry separated by the | character. This indicates that an element matching any one of the ancestry patterns matches the entire pattern. Each ancestry pattern may itself have the capability of a full pattern except for the | operator.

This example creates an fo:sequence for either emph or strong elements:

<xsl:template match="emph | strong">
  <fo:sequence font-weight="bold">
    <xsl:process-children/>
  </fo:sequence>
</xsl:template>

2.6.2 Matching on Element Ancestry

Element ancestry can be represented within the pattern by using the parent operator (/). This operator is based on the familiar directory navigation metaphor. Two patterns separated by the parent operator match an element if the right-hand side matches the element and the left-hand side matches the parent of the element.

For example, the following pattern matches title source elements that have a section element as a parent and a chapter element as a grandparent:

<xsl:template match="chapter/section/title">
  ...
</xsl:template>

While the parent operator specifies a parent-child relationship, the ancestor operator (//) specifies an ancestor-descendant relationship. Two patterns separated by the ancestor operator match an element if the right-hand side matches the element and the element has at least one ancestor that the left-hand side matches. Thus zero or more levels of hierarchy may intervene between the element matching the pattern specified on the left-hand side of the ancestor operator and the element matching the pattern specified on the right-hand side.

This example applies to changed elements which have a para element as an ancestor.

<xsl:template match="para//changed">
  ...
</xsl:template>

2.6.3 Anchors

The first component of an AncestryPattern can be an Anchor. An Anchor is a pattern that only a specific element in the source tree matches (if any elements at all match). The Anchor is said to address the specific element that matches it.

There are two kinds of anchor, relative and absolute. A relative anchor addresses an element relative to the current node. An absolute anchor addresses an element independently of any current node. A match pattern must not contain a RelativeAnchor; all anchors in a match pattern must be absolute. A select pattern may contain both kinds of anchor.

A CurrentNodeAnchor addresses the current node.

A select pattern is implicitly anchored to the current node: if an AncestryPattern in the Pattern does not start with an Anchor or a RootPattern, it is treated as if it were ./AncestryPattern. For example, a select pattern of foo will be treated as ./foo and will thus select the foo children of the current node.

A ParentAnchor addresses the parent of the current node.

2.6.4 Matching the Root Node

A RootPattern matches the root node (see Section 2.4.1: Root Node).

2.6.5 Matching on Element Types

The simplest pattern consists of just an element type name. This matches any element of that type.

<xsl:template match="first-name">
  ...
</xsl:template>

The * pattern is a wildcard that matches a single element of any type. When used within an ancestry chain, the wildcard matches exactly one level of hierarchy.

The following pattern matches any element that is an immediate child of a data-samples element.

<xsl:template match="data-samples/*">
  ...
</xsl:template>

When determining whether a source element matches an ElementTypeName, the expanded element type names are compared (see Section 2.4.2: Element Nodes).

2.6.6 Qualifiers

An element within the pattern hierarchy may have qualifiers applied to it, which further constrain which elements match the term. These qualifiers may constrain the element to have certain attributes or sub-elements or may constrain its position with respect to its siblings. The qualifiers are specified in square brackets ([]) following the element type name or wildcard symbol. A pattern matches only if all of the qualifiers are satisfied.

This example matches author elements within book elements where the book contains at least one excerpt sub-element and the author has a degree attribute:

<xsl:template match="book[excerpt]/author[attribute(degree)]">
  ...
</xsl:template>

2.6.7 Matching on Children

An element can be constrained to have a child element of a particular type by specifying the name of that type as a qualifier.

This example has a pattern that matches author elements within book elements which also have excerpt children (the author and excerpt elements are siblings).

<xsl:template match="book[excerpt]/author">
  ...
</xsl:template>

2.6.8 Matching on Attributes

Attributes on the source element or any of its ancestor elements can also be used to determine whether a particular rule applies to an element. An attribute qualifier constrains an element either to have a specific attribute with a specific value, or to have a specific attribute with any value.

When matching attribute names, the expanded names are compared (see Section 2.4.3: Attribute Nodes).

The following example matches an item element that has for its parent a list element which has a compact attribute:

<xsl:template match="list[attribute(compact)]/item">
  ...
</xsl:template>

The following example matches an item element that has for its parent a list element whose liststyle attribute has the value enum:

<xsl:template match="list[attribute(liststyle)='enum']/item">
  ...
</xsl:template>

It is also possible to select attribute nodes. Within a select pattern, an AncestryPattern can end with an AttributePattern. This will select the attribute node with the specified name for each element in the node list selected by the pattern preceding AttributePattern. Within a match pattern, an AncestryPattern must not end with an AttributePattern.

2.6.9 Matching on Position

Positional qualifiers may be used to further constrain the pattern to match on the element's position or uniqueness among its siblings.

XSL defines the following positional qualifiers:

• first-of-type(). The element must be the first sibling of its type.

• not-first-of-type(). The element must not be the first sibling of its type.

• last-of-type(). The element must be the last sibling of its type.

• not-last-of-type(). The element must not be the last sibling of its type.

• first-of-any(). The element must be the first sibling element of any type.

• not-first-of-any(). The element must not be the first sibling element of any type.

• last-of-any(). The element must be the last sibling element of any type.

• not-last-of-any(). The element must not be the last sibling element of any type.

• only-of-type(). The element must have no element siblings of the same type.

• not-only-of-type(). The element must have one or more element siblings of the same type.

• only-of-any(). The element must have no element siblings at all.

• not-only-of-any(). The element must have one or more element siblings.

The following pattern matches the first item in a list:

<xsl:template match="list/item[first-of-type()]">
  ...
</xsl:template>

The following rule is used for appendix elements when there is only one appendix:

<xsl:template match="backmatter/appendix[only-of-type()]">
  ...
</xsl:template>

2.6.10 Whitespace in Patterns

For readability, whitespace may be used in patterns even though not explicitly allowed by the grammar: PatternWhitespace may be freely added within patterns before or after any PatternToken.

2.6.11 Specificity

When a source element is matched against multiple patterns, it is possible for it to match more than one distinct pattern. In this situation, XSL defines which pattern or patterns are the most specific.

A pattern that starts with an IdAnchor is more specific than a pattern that does not. If two patterns both start with an IdAnchor or both do not start with an IdAnchor, then the one with the more components is the more specific, where a component is either a Qualifier or a OneElementTypePattern.

For example, the following patterns are in decreasing order of specificity:

1. id(employee-of-the-month)

2. employee[attribute(type)='contract',attribute(country)='USA']

3. employee[attribute(type)='contract']

4. employee

5. *

When a pattern contains alternatives separated by |, each alternative is treated separately for specificity purposes. A rule that contains a pattern with two alternatives is equivalent to two rules with the same content each specifying one of the alternatives as its patterns. For example

<xsl:template match="EMPH|B" priority="1">
  <fo:sequence font-weight="bold"><xsl:process-children/></fo:sequence>
</xsl:template>

is equivalent to

<xsl:template match="EMPH" priority="1">
  <fo:sequence font-weight="bold"><xsl:process-children/></fo:sequence>
</xsl:template>
<xsl:template match="B" priority="1">
  <fo:sequence font-weight="bold"><xsl:process-children/></fo:sequence>
</xsl:template>

2.7.1 Overview

When the rule that is to be applied to the source element has been identified, the rule's template is instantiated. A template can contain literal result elements, character data and instructions for creating fragments of the result tree. Instructions are represented by elements in the XSL namespace.

Instructions can select descendant elements for processing. There are two such instructions, the xsl:process-children instruction and the xsl:process instruction; the xsl:process-children instruction processes the immediate children of the source element, while the xsl:process instruction processes elements selected by a specified pattern.

<xsl:template match="chapter/title">
  <fo:rule-graphic/>
  <fo:block space-before="2pt">
    <xsl:text>Chapter </xsl:text>
    <xsl:number/>
    <xsl:text>: </xsl:text>
    <xsl:process-children/>
  </fo:block>
  <fo:rule-graphic/>
</xsl:template>

Note that xsl:process-children selects any character children of the source element as well as the element children. The result in this case is the sequence of results of processing the individual character children and element children in sequence.

2.7.2 Literal Result Elements

In a template an element in the stylesheet that does not belong to the XSL namespace is instantiated to create an element node of the same type; the created element node will have the attributes that were specified on the element in the template tree.

The value of an attribute of a literal result element is interpreted as an attribute value template: it can contain string expressions contained in curly braces ({}).

The namespace prefix map of the result element node is the namespace prefix map of the element node in the stylesheet after the removal of any prefixes that map to the XSL namespace URI.

Since an XSL processor acts on elements belonging to the XSL namespace, the problem arises of how to create elements belonging to the XSL namespace. A namespace whose URI is https://www.w3.org/TR/WD-xsl followed by one or more occurrences of /quote is called a quoted namespace. Quoted namespaces are treated specially: before a result tree is written out as XML all quoted namespace URIs in expanded names and in namespace prefix maps are unquoted by removing the final /quote.

2.7.3 Named Attribute Sets

The xsl:define-attribute-set element defines a named set of attributes. The name attribute specifies the name of the attribute set. The content of the xsl:define-attribute-set element is an xsl:attribute-set element that specifies the attributes. A literal result element or an xsl:attribute-set element can specify an attribute set name as the value of the xsl:use attribute.

The following example creates a named attribute set title-style and uses it in a template rule.

<xsl:define-attribute-set name="title-style">
  <xsl:attribute-set font-size="12pt"
                     font-weight="bold"/>
</xsl:define-attribute-set>

<xsl:template match="chapter/heading">
  <fo:block xsl:use="title-style" quadding="start">
    <xsl:process-children/>
  </fo:block>
</xsl:template>

If the xsl:use attribute is specified on an element that also specifies a value for an attribute that is also part of the attribute set named by xsl:use, the attribute in the named attribute set is not used.

Multiple definitions of an attribute set with the same name are merged. An attribute from a definition that is more important takes precedence over an attribute from a definition that is less important. It is an error if there are two attribute sets with the same name that are equally important and that both contain the same attribute unless there is a more important definition of the attribute set that also contains the attribute. An XSL processor may signal the error; if it does not signal the error, it must recover by choosing from amongst the most important definitions that specify the attribute the one that was specified last in the stylesheet.

An xsl:use attribute may specify a list of attribute set names separated by whitespace. These attribute sets will be merged treating the list as being in order of increasing importance.

2.7.4 Literal Text in Templates

A template can also contain PCDATA. Each data character in a template remaining after whitespace has been stripped as specified in Section 2.4.5: Whitespace Stripping will create a data character in the result tree.

Literal data characters may also be wrapped in an xsl:text element. This wrapping may change what whitespace characters are stripped (see Section 2.4.5: Whitespace Stripping) but does not affect how the characters are handled by the XSL processor thereafter.

2.7.5 Processing with xsl:process-children

This example creates a block for a chapter element and then processes its immediate children.

<xsl:template match="chapter">
  <fo:block>
    <xsl:process-children/>
  </fo:block>
</xsl:template>

The xsl:process-children instruction processes all of the children of the current node, including characters. However, characters that have been stripped as specified in Section 2.4.5: Whitespace Stripping will not be processed.

Processing a character in the source tree adds the character to the result tree. Note that this works at the tree level. Thus, markup of < in content will be represented by a character < in the source tree which will, with the built-in template rules, turn into a < character in the result tree, which would be represented by the markup < (or an equivalent character reference) when the result tree is externalized as an XML document.

2.7.6 Processing with xsl:process

The xsl:process element processes elements selected by a pattern. The pattern of an xsl:process element is a select pattern and so is implicitly anchored to the current node. The following example processes all of the author children of the author-group:

<xsl:template match="author-group">
  <fo:sequence>
    <xsl:process select="author"/>
  </fo:sequence>
</xsl:template>

The xsl:process element processes all elements which match the specified pattern. Character data content is not matched by an xsl:process element. The pattern must not contain an AttributePattern except as part of an AttributeQualifier

The pattern controls the depth at which matches occur. The following example processes all of the first-names of the authors that are direct children of author-group:

<xsl:template match="author-group">
  <fo:sequence>
    <xsl:process select="author/first-name"/>
  </fo:sequence>
</xsl:template>

The // operator can be used in the pattern to allow the matches to occur at arbitrary depths.

This example processes all of the heading elements contained in the book element.

<xsl:template match="book">
  <fo:block>
    <xsl:process select=".//heading"/>
  </fo:block>
</xsl:template>

An AncestorAnchor in the pattern allows the processing of elements that are not descendants of the current node. This example finds an employee's department and then processes the group children of the department.

<xsl:template match="employee">
  <fo:block>
    Employee <xsl:process select="name"/> belongs to group
    <xsl:process select="ancestor(department)/group"/>
  </fo:block>
</xsl:template>

This example assumes that a department element contains group and employee elements (at some level). When processing the employee elements, the AncestorAnchor in the pattern allows navigation upward to the department element in order to extract the information about the group to which the employee belongs.

An IdAnchor allows processing of elements with a specific ID. For example, this template rule applies to elements with the ID cfo; the second xsl:process element processes the name child of the element with ID ceo:

<xsl:template match="id(cfo)">
  <xsl:process select="name"/> reports to <xsl:process select="id(ceo)/name"/>
</xsl:template>

Multiple xsl:process elements can be used within a single template to do simple reordering. The following example creates two HTML tables. The first table is filled with domestic sales while the second table is filled with foreign sales.

<xsl:template match="product">
  <TABLE>
    <xsl:process select="sales/domestic"/>
  </TABLE>
  <TABLE>
    <xsl:process select="sales/foreign"/>
  </TABLE>
</xsl:template>

Use of Anchors in patterns in xsl:process can lead to infinite loops. It is an error if, during the invocation of a rule for an element, that same rule is invoked again for that element. An XSL processor may signal the error; if it does not signal the error, it must recover by creating an empty result tree structure for the nested invocation.

2.7.7 Direct Processing

When the result has a known regular structure, it is useful to be able to specify directly the template for selected elements. The xsl:for-each element contains a template which is instantiated for each element selected by the pattern specified by the select attribute.

For example, given an XML document with this structure

<customers>
  <customer>
    <name>...</name>
    <order>...</order>
    <order>...</order>
  </customer>
  <customer>
    <name>...</name>
    <order>...</order>
    <order>...</order>
  </customer>
</customers>

the following would create an HTML document containing a table with a row for each customer element

<xsl:template match="/">
  <HTML>
    <HEAD>
      <TITLE>Customers</TITLE>
    </HEAD>
    <BODY>
      <TABLE>
    <TBODY>
      <xsl:for-each select="customers/customer">
        <TR>
          <TH>
        <xsl:process select="name"/>
          </TH>
          <xsl:for-each select="order">
        <TD>
          <xsl:process-children/>
        </TD>
          </xsl:for-each>
        </TR>
      </xsl:for-each>
    </TBODY>
      </TABLE>
    </BODY>
  </HTML>
</xsl:template>

As with xsl:process the pattern is a select pattern and so is implicitly anchored to the current node. The select attribute is required. The pattern must not contain an AttributePattern except as part of an AttributeQualifier.

2.7.8 Numbering in the Source Tree

The xsl:number element does numbering based on the position of the current node in the source tree.

The xsl:number element can have the following attributes:

• The level attribute specifies what levels of the source tree should be considered; it has the values single, multi or any. The default is single.

• The count attribute is a match pattern that specifies what elements should be counted at those levels. The count attribute defaults to the element type name of the current node.

• The from attribute is a match pattern that specifies where counting starts from.

In addition the xsl:number element has the attributes specified in Section 2.7.9: Number to String Conversion Attributes for number to string conversion.

The xsl:number element first constructs a list of positive integers using the level, count and from attributes:

• When level="single", it goes up to the nearest ancestor (including the current node as its own ancestor) that matches the count pattern, and constructs a list of length one containing one plus the number of preceding siblings of that ancestor that match the count pattern. If there is no such ancestor, it constructs an empty list. If the from attribute is specified, then the only ancestors that are searched are those that are descendants of the nearest ancestor that matches the from pattern.

• When level="multi", it constructs a list of all ancestors of the current node in document order followed by the element itself; it then selects from the list those elements that match the count pattern; it then maps each element of the list to one plus the number of preceding siblings of that element that match the count pattern. If the from attribute is specified, then the only ancestors that are searched are those that are descendants of the nearest ancestor that matches the from pattern.

• When level="any", it constructs a list of length one containing one plus number of elements at any level of the document that start before this node and that match the count pattern. If the from attribute is specified, then only elements after the first element before this element that match the from pattern are considered.

The list of numbers is then converted into a string using the attributes specified in Section 2.7.9: Number to String Conversion Attributes; when used with xsl:number the value of each of these attributes is interpreted as an attribute value template. After conversion, the resulting string is inserted in the result tree.

The following would number the items in an ordered list:

<xsl:template match="ol/item">
  <fo:block>
    <xsl:number/><xsl:text>. </xsl:text><xsl:process-children/>
  </fo:block>
<xsl:template>

The following two rules would number title elements. This is intended for a document that contains a sequence of chapters followed by a sequence of appendices, where both chapters and appendices contain sections which in turn contain subsections. Chapters are numbered 1, 2, 3; appendices are numbered A, B, C; sections in chapters are numbered 1.1, 1.2, 1.3; sections in appendices are numbered A.1, A.2, A.3.

<xsl:template match="title">
  <fo:block>
     <xsl:number level="multi"
                 count="chapter|section|subsection"
                 format="1.1. "/>
     <xsl:process-children/>
  </fo:block>
</xsl:template>

<xsl:template match="appendix//title">
  <fo:block>
     <xsl:number level="multi"
                 count="appendix|section|subsection"
                 format="A.1. "/>
     <xsl:process-children/>
  </fo:block>
</xsl:template>

The following example numbers notes sequentially within a chapter:

<xsl:template match="note">
  <fo:block>
     <xsl:number level="any" from="chapter" format="(1) "/>
     <xsl:process-children/>
  </fo:block>
</xsl:template>

The following example would number H4 elements in HTML with a three-part label:

<xsl:template match="H4">
 <fo:block>
   <xsl:number level="any" from="H1" count="H2"/>
   <xsl:text>.</xsl:text>
   <xsl:number level="any" from="H2" count="H3"/>
   <xsl:text>.</xsl:text>
   <xsl:number level="any" from="H3" count="H4"/>
   <xsl:text> </xsl:text>
   <xsl:process-children/>
 </fo:block>
</xsl:template>

2.7.9 Number to String Conversion Attributes

The following attributes are used to control conversion of a list of numbers into a string. The numbers are integers greater than 0. The attributes are all optional.

The main attribute is format. The default value for the format attribute is 1. The format attribute is split into a sequence of tokens where each token is a maximal sequence of alphanumeric characters or a maximal sequence of non-alphanumeric characters. The alphanumeric tokens (format tokens) specify the format to be used for each number in the list; the non-alphanumeric tokens (separator tokens) specify the separators used to join numbers in the list. Alphanumeric means any character that has a Unicode category of Nd, Nl, No, Lu, Ll, Lt, Lm or Lo. If the first token is a separator token, then the constructed string will start with that token; if the last token is a separator token, then the constructed string will end with that token. The n-th format token will be used to format the n-th number in the list. If there are more numbers than format tokens, then the last format token will be used to format remaining numbers. The format token specifies the string to be used to represent the number 1. If there are more than n numbers, then the n-th number will be separated from the following number by the separator token following the n-th format token; if there is no such separator token, then the last separator token will be used; if there are no separator tokens, then . will be used.

Format tokens are a superset of the allowed values for the type attribute for the OL element in HTML 4.0 and are interpreted as follows:

• Any token where the last character has a decimal digit value of 1 (as specified in the Unicode 2.0 character property database), and the Unicode value of preceding characters is one less than the Unicode value of the last character. This generates a decimal representation of the number where each number is at least as long as the format token. Thus a format token 1 generates the sequence 1 2 ... 10 11 12 ..., and a format token 01 generates the sequence 01 02 ... 09 10 11 12 ... 99 100 101.

• A format token A generates the sequence A B C ... Z AA AB AC....

• A format token a generates the sequence a b c ... z aa ab ac....

• A format token i generates the sequence i ii iii iv v vi vii vii ix x ....

• A format token I generates the sequence I II III IV V VI VII VII IX X ....

• Any other format token indicates a numbering sequence that starts with that token. If an implementation does not support a numbering system that starts with that token, it must use a format token of 1.

When numbering with an alphabetic sequence, the xml:lang attribute specifies which language's alphabet is to be used.

The letter-value attribute disambiguates between numbering schemes that use letters. In many languages there are two commonly used numbering schemes that use letters. One numbering scheme assigns numeric values to letters in alphabetic sequence, and the other assigns numeric values to each letter in some other manner. In English, these would correspond to the numbering sequences specified by the format tokens a and i. In some languages the first member of each sequence is the same, and so the format token alone would be ambiguous. A value of alphabetic specifies the alphabetic sequence; a value of other specifies the other sequence.

The digit-group-sep attribute gives the separator between groups of digits, and the optional n-digits-per-group specifies the number of digits per group. For example, digit-group-sep="," and n-digits-per-group="3" would produce numbers of the form 1,000,000.

The sequence-src attribute gives the URI of a text resource that contains a whitespace separated list of the members of the numbering sequence.

Here are some examples of conversion specifications:

• format="ア" specifies Katakana numbering

• format="イ" specifies Katakana numbering in the "iroha" order

• format="๑" specifies numbering with Thai digits

• format="א" letter-value="other" specifies "traditional" Hebrew numbering

• format="ა" letter-value="other" specifies Georgian numbering

• format="α" letter-value="other" specifies "classical" Greek numbering

• format="а" letter-value="other" specifies Old Slavic numbering

2.7.10 Conditionals within a Template

There are two instructions in XSL which support conditional processing in a template: xsl:if and xsl:choose. The xsl:if instruction provides simple if-then conditionality; the xsl:choose instruction supports selection of one choice when there are several possibilities.

<xsl:template match="namelist/name">
  <xsl:process-children/>
  <xsl:if test=".[not-last-of-type()]">, </xsl:if>
</xsl:template>

<xsl:template match="orderedlist/listitem">
  <fo:list-item indent-start='2pi'>
    <fo:list-item-label>
      <xsl:choose>
        <xsl:when test='ancestor(orderedlist/orderedlist)'>
          <xsl:number format="i"/>
        </xsl:when>
        <xsl:when test='ancestor(orderedlist)'>
          <xsl:number format="a"/>
        </xsl:when>
        <xsl:otherwise>
          <xsl:number format="1"/>
        </xsl:otherwise>
      </xsl:choose>
      <xsl:text>. </xsl:text>
    </fo:list-item-label>
    <fo:list-item-body>
      <xsl:process-children/>
    </fo:list-item-body>
  </fo:list-item>
</xsl:template>

2.7.11 Computing Generated Text

Within a template, the xsl:value-of element can be used to compute generated text, for example by extracting text from the source tree or by inserting the value of a string constant. The xsl:value-of element does this with a string expression that is specified as the value of the expr attribute. String expressions can also be used inside attribute values of literal result elements by enclosing the string expression in curly brace ({}).

<xsl:template match="person">
  <P>
   <xsl:value-of expr="attribute(first-name)"/>
   <xsl:text> </xsl:text>
   <xsl:value-of expr="attribute(surname)"/>
  </P>
</xsl:template>

<xsl:template match="person">
  <P>
   <xsl:value-of expr="first-name"/>
   <xsl:text> </xsl:text>
   <xsl:value-of expr="surname"/>
  </P>
</xsl:template>

<xsl:template match="procedure">
  <fo:block>
    <xsl:value-of expr="ancestor(*[attribute(security)])/attribute(security)"/>
  </fo:block>
  <xsl:process-children/>
</xsl:template>

<xsl:define-constant name="image-dir" value="/images"/>

<xsl:template match="photograph">
<IMG SRC="{constant(image-dir)}/{href}" WIDTH="{size/attribute(width)}"/>
</xsl:template>

<photograph>
  <href>headquarters.jpg</href>
  <size width="300"/>
</photograph>

<IMG SRC="/images/headquarters.jpg" WIDTH="300"/>

<a href="#{id({attribute(ref)})/title}">

2.7.12 String Constants

Global string constants may be defined using a define-constant element. The name attribute specifies the name of the constant, and the value attribute specified the value.

A stylesheet must not contain more than one definition of a constant with the same name and same importance. A definition of a constant will not be used if there is another definition of a constant with the same name and higher importance.

String constants are referenced using a ConstantRef string expression.

<xsl:define-constant name="para-font-size" value="12pt"/>

<xsl:template match="para">
 <fo:block font-size="{constant(para-font-size)}">
   <xsl:process-children/>
 </fo:block>
</xsl:template>

The value attribute is interpreted as an attribute value template. If the value of a constant definition x references a constant y, then the value for y must be computed before the value of x. It is an error if it is impossible to do this for all constant definitions because of dependency cycles.

2.7.13 Macros

Parts of templates can also be factored out of similar rules into macros for reuse. Macros allow authors to create aggregate result fragments and refer to the composite as if it were a single object. In this example, a macro is defined for a boxed paragraph with the word "Warning!" preceding the contents. The macro is referenced from a rule for warning elements.

<xsl:define-macro name="warning-para">
  <fo:box>
    <fo:block>
      <xsl:text>Warning! </xsl:text>
      <xsl:contents/>
    </fo:block>
  </fo:box>
</xsl:define-macro>

<xsl:template match="warning">
  <xsl:invoke macro="warning-para">
    <xsl:process-children/>
  </xsl-invoke>
</xsl:template>

Macros are defined using the define-macro element. The name attribute specifies the name of the macro being defined. The content of the define-macro element is a template, called the body of the macro. A macro is invoked using the xsl:invoke element; the content of xsl:invoke is a template. The name of the macro to be invoked is given by the macro attribute. Invoking a macro first instantiates the content of xsl:invoke. It then instantiates the body of the invoked macro passing it the result tree fragment created by the instantiation of the content of xsl:invoke; this fragment can be inserted in the body of the macro using the xsl:contents element.

Macros allow named arguments to be declared with the xsl:macro-arg element; the name attribute specifies the argument name, and the optional default attribute specifies the default value for the argument. Within the body of a macro, macro arguments are referenced using a MacroArgRef string expression. It is an error to refer to a macro argument that has not been declared. An XSL processor may signal the error; if it does not signal the error, it must recover by using an empty string. Arguments are supplied to a macro invocation using the code xsl:arg element; the name attribute specifies the argument name, and the value attribute specifies the argument value. It is an error to supply an argument to a macro invocation if the macro did not declare an argument of that name. An XSL processor may signal the error; if it does not signal the error, it must recover by ignoring the argument. The value attribute of xsl:arg and the default attribute of xsl:macro-arg are interpreted as attribute value templates; they can contain string expressions in curly braces as with literal result elements.

This example defines a macro for a numbered-block with an argument to control the format of the number.

<xsl:define-macro name="numbered-block">
  <xsl:macro-arg name="format" default="1. "/>
  <xsl:number format="{arg(format)}"/>
  <fo:block/>
    <xsl:contents/>
  </fo:block>
</xsl:define-macro>

<xsl:template match="appendix/title">
  <xsl:invoke name="numbered-block">
    <xsl:arg name="format" value="A. "/>
    <xsl:process-children/>
  </xsl:invoke>
</xsl:template>

It is an error if a stylesheet contains more than one definition of a macro with the same name and same importance. An XSL processor may signal the error; if it does not signal the error, if must recover by choosing from amongst the definitions with highest importance the one that occurs last in the stylesheet.

2.9.1 Stylesheet Import

An XSL stylesheet may contain xsl:import elements. All the xsl:import elements must occur at the beginning of the stylesheet. The xsl:import element has an href attribute whose value is the URI of a stylesheet to be imported. A relative URI is resolved relative to the base URI of the xsl:import element (see Section 2.4.2.2: Base URI).

<xsl:stylesheet xmlns:xsl="https://www.w3.org/TR/WD-xsl">
  <xsl:import href="article.xsl"/>
  <xsl:import href="bigfont.xsl"/>
  <xsl:define-attribute-set name="note-style">
    <xsl:attribute-set font-posture="italic"/>
  </xsl:define-attribute-set>
</xsl:stylesheet>

Rules and definitions in the importing stylesheet are defined to be more important than rules and definitions in any imported stylesheets. Also rules and definitions in one imported stylesheet are defined to be more important than rules and definitions in previous imported stylesheets.

In general a more important rule or definition takes precedence over a less important rule or definition. This is defined in detail for each kind of rule and definition.

2.9.2 Stylesheet Inclusion

An XSL stylesheet may include another XSL stylesheet using an xsl:include element. The xsl:include element has an href attribute whose value is the URI of a stylesheet to be included. A relative URI is resolved relative to the base URI of the xsl:include element (see Section 2.4.2.2: Base URI). The xsl:include element can occur as the child of the xsl:stylesheet element at any point after all xsl:import elements.

The inclusion works at the XML tree level. The resource located by the href attribute value is parsed as an XML document, and the children of the xsl:stylesheet element in this document replace the xsl:include element in the including document. Also any xsl:import elements in the included document are moved up in the including document to after any existing xsl:import elements in the including document. Unlike with xsl:import, the fact that rules or definitions are included does not affect the way they are processed.

2.9.3 Embedding Stylesheets

Normally an XSL stylesheet is a complete XML document with the xsl:stylesheet element as the document element. However an XSL stylesheet may also be embedded in another resource. Two forms of embedding are possible:

• the XSL stylesheet may be textually embedded in a non-XML resource, or
• the xsl:stylesheet element may occur in an XML document other than as the document element.

In the second case, the possibility arises of documents with inline style, that is documents that specify their own style. XSL does not define a specific mechanism for this. This is because this can be done by means of a general purpose mechanism for associating stylesheets with documents provided that:

• the mechanism allows a part of a resource to be specified as the stylesheet, for example by using a URI with a fragment identifier, and
• the mechanism can itself can be embedded in the document, for example as a processing instruction.

It is not in the scope of XSL to define such a mechanism.

The xsl:stylesheet element may have an ID attribute that specifies a unique identifier.

The following example shows how inline style can be accomplished using the xml:stylesheet processing instruction mechanism for associating a stylesheet with an XML document. The URI uses an XPointer in a fragment identifier to locate the xsl:stylesheet element.

<?xml version="1.0"?>
<?xml:stylesheet type="text/xsl" href="#id(style1)"?>
<!DOCTYPE doc SYSTEM "doc.dtd">
<doc>
<head>
<xsl:stylesheet xmlns:xsl="https://www.w3.org/TR/WD-xsl" id="style1">
<xsl:import href="doc.xsl"/>
<xsl:template match="id(foo)">
 <fo:block font-weight="bold"><xsl:process-children/></fo:block>
</xsl:template>
</xsl:stylesheet>
</head>
<body>
<para id="foo">
...
</para>
</body>
</doc>

3.5.1 Purpose

This object describes the general layout or layout sequencing for web page (both print and online).

A page-sequence holds:

• a number of child simple-page-masters that define the layouts to be used for this sequence.

• a number of child queues which hold the content to be placed in this sequence.

  Ed. Note: To support layout-driven documents in future drafts, the queues may not be held by the "page-sequence" and may be moved to a separate mapping object.

  NOTE: A document can contain multiple page-sequences. For example, each chapter of a document could be a separate page-sequence; this would allow the chapter title within a header or footer.

3.5.2 Formatting Object Summary

<fo:page-sequence

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:page-sequence>

3.5.3 Formatting Object's Formal Specification

A page-sequence holds:

• one or more child simple-page-masters that define the layouts to be used for this sequence

• one or more child queues which hold the content to be placed in this sequence.

3.5.4 To Resolve

• Media selection:

  We have defined a master for scrolling and separate masters for paged presentations. In James' note on "Linking Stylesheets to XML Documents" he describes a simple mechanism to support media-driven selection of different stylesheets. We do not currently have a mechanism for supporting media switches within a stylesheet.

  Media selection interacts with sequence specification.

• Sequences:

  Ed. Note: A method to define the sequencing of page masters will be provided in a future draft.

3.6.1 Purpose

A simple-page-master formatting object defines the layout of a page area. Masters may be repeated in accordance with the page-sequence specification.

The simple-page-master defines 5 areas for presentation within the page/window design (formatted area of the page). These are the header, body, footer, start-side, and end-side. It also provides a title, which has no properties defined in the simple-page-master object, but may for example be presented in a browser's title bar.

first

A simple-page-master with master-name=first.

The master to be used for the first page in the sequence.

odd

A simple-page-master with master-name=odd.

The master to be used for odd-phased pages after the first page in the sequence.

even

A simple-page-master with master-name=even.

The master to be used for even-phased pages after the first page in the sequence.

For single-sided printing and paged online presentation, this master can be dropped.

scrolling

A simple-page-master with master-name=scrolling.

The master to be used for scrolling (non-paged) online presentation.

3.6.2 Formatting Object Summary

<fo:simple-page-master

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

master-name (DSSSL:-none-, CSS:-none-) = name-specifier

Required

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

page-height (DSSSL:-same-, CSS:height) = length-specifier

Value(s): {auto | 0..max-length}

Inherited, Initial = auto

page-width (DSSSL:-same-, CSS:width) = length-specifier

Value(s): {auto | 0..max-length}

Inherited, Initial = auto

page-writing-mode (DSSSL:-none-, CSS:-none-) = writing-mode-specifier

Inherited, Initial = lr-tb

margin-bottom (DSSSL:bottom-margin, CSS:margin-bottom) = length-specifier

Value(s): {0..page-height}

Inherited, Initial = 36.0pt

margin-left (DSSSL:left-margin, margin-left) = length-specifier

Value(s): {0..page-width}

Inherited, Initial = 36.0pt

margin-right (DSSSL:right-margin, CSS:margin-right) = length-specifier

Value(s): {0..page-width}

Inherited, Initial = 36.0pt

margin-top (DSSSL:top-margin, CSS:margin-top) = length-specifier

Value(s): {0..page-height}

Inherited, Initial = 36.0pt

body-overflow (DSSSL:-none-, CSS:overflow) = ( visible | hidden | scroll | auto )

Inherited, Initial = auto

body-writing-mode (DSSSL:-none-, CSS:-none) = a writing-mode-specifier | use-page-writing-mode

Inherited, Initial = use-page-writing-mode

end-side-overflow (DSSSL:-none-, CSS:overflow) = ( visible | hidden | scroll | auto )

Inherited, Initial = auto

end-side-separation (DSSSL:-none-, CSS:-none-) = length-specifier

Value(s): {0.. available-size}

Inherited, Initial = 0.0pt

end-side-size (DSSSL:-none-, CSS:-none-) = length-specifier

Value(s): {0..page-height}

Inherited, Initial = 0.0pt

end-side-writing-mode (DSSSL:-none-, CSS:-none-) = a writing-mode-specifier | use-page-writing-mode

Inherited, Initial = use-page-writing-mode

footer-overflow (DSSSL:-none-, CSS:overflow) = ( visible | hidden | scroll | auto )

Inherited, Initial = auto

footer-precedence (DSSSL:-none-, CSS:-none) = ( true | false )

Inherited, Initial = true

footer-separation (DSSSL:footer-margin, CSS:-none-) = length-specifier

Value(s): {0.. available-size}

Inherited, Initial = 18.0pt

footer-size (DSSSL:-none-, CSS:-none-) = length-specifier

Value(s): {0..page-height}

Inherited, Initial = 36.0pt

footer-writing-mode (DSSSL:-none-, CSS:-none) = a writing-mode-specifier | use-page-writing-mode

Inherited, Initial = use-page-writing-mode

header-overflow (DSSSL:-none-, CSS:overflow) = ( visible | hidden | scroll | auto )

Inherited, Initial = auto

header-precedence (DSSSL:-none-, CSS:-none) = ( true | false )

Inherited, Initial = true

header-separation (DSSSL:header-margin, CSS:-none-) = length-specifier

Value(s): {0.. available-size}

Inherited, Initial = 18.0pt

header-size (DSSSL:-none-, CSS:-none-) = length-specifier

Value(s): {0..page-height}

Inherited, Initial = 36.0pt

header-writing-mode (DSSSL:-none-, CSS:-none) = a writing-mode-specifier | use-page-writing-mode

Inherited, Initial = use-page-writing-mode

start-side-separation (DSSSL:-none-, CSS:-none-) = length-specifier

Value(s): {0.. available-size}

Inherited, Initial = 0.0pt

start-side-size (DSSSL:-none-, CSS:-none-) = length-specifier

Value(s): {0..page-height}

Inherited, Initial = 0.0pt

start-side-overflow (DSSSL:-none-, CSS:overflow) = ( visible | hidden | scroll | auto )

Inherited, Initial = auto

start-side-writing-mode (DSSSL:-none-, CSS:-none) = a writing-mode-specifier | use-page-writing-mode

Inherited, Initial = use-page-writing-mode

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:simple-page-master>

3.6.3 Formatting Object's Formal Specification

A simple-page-master is formatted to produce a sequence of page areas.

A simple-page-master shall be allowed only within the page-sequence.

The simple-page-master supports only the sequential-tiled-page-model, with an ordered set of up to 5 of the following areas: header, body, footer, end-side, and start-side. The user may specify the size (height or width) of the header, footer, end-side, and start-side areas and the separation distances between the adjacent areas. The height of the body area is the page's size (page-height for horizontal writing-modes, and page-width for vertical writing-modes) minus the sum of the header & footer heights, the separations between the areas, and the page's margin in the block-progression-direction.

The stacking direction of the areas, the page and area heights and separation distances are in the direction specified by the writing-mode's block-progression-direction.

The width of each area is the full available distance in the inline-progression-direction after subtracting the page's margin (and may not be negative).

A simple-page-master may use up to 6 associated queues. These queues are not direct children of the page-sequence (but are associated with it by name or via an explicit mapping table).

title

A queue with queue-name=title.

For online presentations only, this object holds a single title textline to be presented in the window title bar when this simple-page-master is being viewed.

If provided for print environments, this object is ignored.

If there is too much text for the title area, the browser may truncate the presentation.

The content of a title is repeated on each page by replaying the title queue after the body area is processed. (This allows for proper presentation of "dictionary"-style running headers/footers.)

header

A queue with queue-name=header.

Holds the content to be placed in the header area(s).

For print and online environments, this object holds a set of information that is presented in a separate area at the top of the page or window.

Ed. Note: As defined by writing-mode, we need a term for relative directions that is invariant across inline and block-level objects.

If there is too much text for the header area, the presentation may be truncated/clipped.

The content of a header is repeated on each page by replaying the header queue after the body area is processed. (This allows for proper presentation of "dictionary"-style running headers/footers.)

footer

A queue with queue-name=footer.

Holds the content to be placed in the footer area(s).

For print and online environments, this holds a set of information that is presented in a separate area at the bottom of the page or window.

If there is too much text for the footer area, the presentation may be truncated/clipped.

The content of a footer is repeated on each page by replaying the footer queue after the body area is processed. (This allows for proper presentation of "dictionary"-style running headers/footers.)

start-side

A queue with queue-name=start-side.

Holds the content to be placed in the start-side area(s).

For print and online environments, this object holds a set of information that is presented in a separate area at the starting edge (as specified by the page-writing-mode property) of the page or window.

If there is too much text for the start-side area, the presentation may be truncated/clipped.

The content of a start-side area is repeated on each page by replaying the start-side queue after the body area is processed. (This allows for proper presentation of "dictionary"-style running headers/footers.)

end-side

A queue with queue-name=end-side.

Holds the content to be placed in the end-side area(s).

For print and online environments, this holds a set of information that is presented in a separate area at the ending edge of the page or window.

If there is too much text for the end-side area, the presentation may be truncated/clipped.

The content of a end-side area is repeated on each page by replaying the end-side queue after the body area is processed. (This allows for proper presentation of "dictionary"-style running headers/footers.)

body

A queue with queue-name=body.

Holds the content to be placed in the body area(s).

For print and online environments, this holds the information that is presented in the main area in the middle of the page or window.

In a print environment, if there is too much text for the body area the formatter should create additional pages until all the content is presented.

In a online environment, if there is too much text for the body area the formatter can create additional pages/frames/panels until all the content is presented or it can present the content in a scrolling view.

3.6.4 To Resolve

Should defaults be in points? CSS has made the recommendation that pixels are preferred due to issues with browsers & video-drivers. The print industry wants a "real" measurements system, such as points or mm. Points are not nationally biased and the "computer point" has been widely accepted.

How to handle left, right, and centered header & footer areas in the simple-page-master.

3.7.1 Purpose

A queue is used to gather content flow objects to be assigned to (placed into) a given area or set of chained-areas.

3.7.2 Formatting Object Summary

<fo:queue

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

queue-name (DSSSL:-none-, CSS:-none-) = name-specifier

Required

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:queue>

3.7.3 Formatting Object's Formal Specification

A queue shall not be allowed within the content of any formatting object except a page-sequence.

The queue holds a sequence or tree of formatting-objects that is to be presented in a like-named area of the layout defined by the simple-page-master.

The following properties apply to a queue:

• queue-name specifies the area name in the parent object into which this object's content will be placed.

  For the simple-page-master, the queue-name may be: title, header, body, footer, start-side, or end-side. If two or more queues have the same queue-name, the like-named queues will be merged into a single queue.

3.8.1 Purpose

A sequence is used to group flow objects and to assign inherited properties to be shared across them. (Note the difference between a queue and a sequence.)

3.8.2 Formatting Object Summary

<fo:sequence

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:sequence>

3.8.3 Formatting Object's Formal Specification

A sequence formatting object is formatted to produce the series of the areas produced by each of its children. This object holds its content as children. Its children may be all inline, all block-level, or a mixture of inline & block-level, if so allowed within the sequence's parent.

A sequence shall accept a formatting object if and only if its parent would accept the formatting objects in that sequence.

A sequence has no applicable properties.

3.9.1 Purpose

A block formatting object allows the formatter to create a block-level area that contains textlines.

This object is commonly used for formatting paragraphs, titles, headlines, figure and table captions, etc.

It normally specifies a rectangular area that occupies the width of the containing area and a height that is determined by the amount of text that the block contains.

A block may specify separation between it and a preceding block-level object or subsequent block-level object as well as unique indents on the start of the first textline of the block and end of the last textline of the block.

3.9.2 Formatting Object Summary

<fo:block

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

language (DSSSL:language & D:country, CSS:-none-) = ( none | use-document | an xml:lang specifier )

Inherited, Initial = use-document

NOTE: The value use-document specifies one should use the language/country/script specified in the source document's xml:lang specifier. -- An explicit value has the same form as the xml:lang specifier and overrides the language derived through xml:lang. -- Choosing "none" disables hyphenation and forces a simple line-breaking strategy. Used for program text and poetry.

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

font-family (DSSSL:font-family-name, CSS:-same-) = font-name or font-name-list

Inherited, Initial = any

font-style (DSSSL:font-posture, CSS:-same-) = ( normal | italic | oblique | -TBD- (check CSS) )

Inherited, Initial = normal

font-stretch (DSSSL:font-proportionate-width, CSS:-same-) = ( ultra-condensed | extra-condensed | condensed | semi-condensed | normal | semi-expanded | expanded | extra-expanded | ultra-expanded )

Inherited, Initial = normal

font-size (DSSSL:-same-, CSS:-same-) = length-specifier

Value(s): {1.0pt...1024.0pt}

Inherited, Initial = 10.0pt (DSSSL)

font-size-adjust (DSSSL:-none-, CSS:-same-) = length-specifier

Value(s): {TBD...TBD}

Inherited, Initial = TBD

font-variant (DSSSL:-none-, CSS:-same-) = ( normal | small-caps )

Inherited, Initial = normal

font-weight (DSSSL:-same-, CSS:-same-) = ( any | not-applicable | ultra-light | extra-light | light | semi-light | book (added) | normal (added) | medium | semi-bold | bold | extra-bold | ultra-bold | ... (See CSS & PANOSE) )

Inherited, Initial = normal

glyph-alignment-mode (DSSSL:-same-) = ( base | center | top | bottom | font )

Inherited, Initial = font

NOTE: Used to set the textline's placement-path position relative to the origin of the block-level area. (See the extended description of "Textline Spacing", following this section.) Used to set alignment-line or placement-path. CSS supports only font. Non-core

indent-end (DSSSL:end-indent, CSS:-object-margin-) = length-specifier

Value(s): {0.0pt...available-width}

Inherited, Initial = 0.0pt

indent-start (DSSSL:start-indent, CSS:-object-margin-) = length-specifier

Value(s): {0.0pt...available-width}

Inherited, Initial = 0.0pt

indent-first-line-start (DSSSL:first-line-start-indent, CSS:text-indent) = length-specifier

Value(s): {-indent-start...available-width}

Optional (Non-inherited), Default = 0.0pt

NOTE: (CSS/DSSSL differ) Confirm that this is ADDED to the indent-start, not a replacement.

break-after (DSSSL:-same-) = ( none | page | page-odd | page-even )

Optional (Non-inherited), Default = none

break-before (DSSSL:-same-) = ( none | page | page-odd | page-even )

Optional (Non-inherited), Default = none

keep (DSSSL:-same-) = ( auto | no-break | page )

Optional (Non-inherited), Default = auto

NOTE: A value of no-break specifies the object may not be broken. A value of auto specifies that it may be broken in accordance with the widow/orphan specifier. All other values indicate that this object shall be together as a single unit if it would break over the boundary indicated by the property value.

orphans (DSSSL:orphan-count, CSS:orphans) = integer

Value(s): {0...999}

Inherited, Initial = 2

widows (DSSSL:widow-count, CSS:widows) = integer

Value(s): {0...999}

Inherited, Initial = 2

keep-with-next (DSSSL:-same-) = ( true | false )

Optional (Non-inherited), Default = false

keep-with-previous (DSSSL:-same-) = ( true | false )

Optional (Non-inherited), Default = false

block-line-breaking (DSSSL:lines) = ( wrap | asis | as-is-wrap | asis-truncate | none )

Inherited, Initial = wrap

block-asis-truncate-indicator (DSSSL:asis-truncate-char) = ( none | a character )

Inherited, Initial = none

NOTE: Non-core

block-asis-wrap-indicator (DSSSL:asis-wrap-char) = ( none | a character )

Inherited, Initial = none

NOTE: Non-core

block-asis-wrap-indent (DSSSL:asis-wrap-indent) = length-specifier

Value(s): {-indent-start...-TBD-}

Inherited, Initial = 0.0pt

NOTE: Non-core

hyphenation-keep (DSSSL:-same-) = ( none | spread | page | column )

Inherited, Initial = none

NOTE: Non-core

hyphenation-ladder-count (DSSSL:-same-) = integer

Value(s): {1...999}

Inherited, Initial = 2

NOTE: Non-core

text-align (DSSSL:quadding, CSS:text-align) = ( start | end | left | right | spread-inside | spread-outside | page-inside (Defer) | page-outside (Defer) | center | justify | justify-force )

Inherited, Initial = start

text-align-last (DSSSL:last-line-quadding, CSS:-none-) = ( auto | start | end | left | right | spread-inside | spread-outside | page-inside (Defer) | page-outside (Defer) | center | justify )

Inherited, Initial = start

NOTE: Non-core

linespacing-strategy (DSSSL: #f on min-leading) = ( fixed | auto )

Inherited, Initial = auto

linespacing (DSSSL:line-spacing) = length-specifier

Value(s): {0.0pt...-TBD-}

Inherited, Initial = 12.0pt

space-after-maximum (DSSSL:space-after) = length-specifier

Value(s): {--TBD-...-TBD-}

Optional (Non-inherited), Default = 0.0pt

NOTE: Non-core

space-after-minimum (DSSSL:space-after) = length-specifier

Value(s): {--TBD-...-TBD-}

Optional (Non-inherited), Default = 0.0pt

NOTE: Non-core

space-after-optimum (DSSSL:space-after) = length-specifier

Value(s): {--TBD-...-TBD-}

Optional (Non-inherited), Default = 0.0pt

space-before-maximum (DSSSL:space-before) = length-specifier

Value(s): {--TBD-...-TBD-}

Optional (Non-inherited), Default = 0.0pt

NOTE: Non-core

space-before-minimum (DSSSL:space-before) = length-specifier

Value(s): {--TBD-...-TBD-}

Optional (Non-inherited), Default = 0.0pt

NOTE: Non-core

space-before-optimum (DSSSL:space-before) = length-specifier

Value(s): {--TBD-...-TBD-}

Optional (Non-inherited), Default = 0.0pt

writing-mode (DSSSL:-same-) = writing-mode-specifier

Inherited, Initial = lr-tb

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:block>

3.9.3 Formatting Object's Formal Specification

A block is a block-level formatting object.

A block directly contains its children, which may be a mixture of inline or block-level formatting objects.

• Inline child formatting objects within a block are formatted to produce one or more textline areas. Multiple inline objects may be placed successively into a single textline. Inline objects may (or may not) be split across two or more textlines if necessary (and if allowed to split) if the inline does not fit in the remaining space in the textline.

• Block-level child formatting objects within a block implicitly specify line-breaks before and after the block-level object. Each child block-level produces a single area which is treated by the formatter of the block as if it were a textline area. These areas shall be added to the resulting sequence of areas within the block.

  NOTE: This specifies that users may nest a block inside another block. When this happens the outer block does not end before the nested block, it is simply suspended. The normal mid-block quadding and indents apply to the last textline prior to the nested block's area. Similarly, the outer block resumes after the nested block without a new first-textline indent.

  NOTE: Typically, a break implies that a new textline is to be started.

  The shift-direction for inline areas in the block is the reverse of the line-progression-direction of the block.

3.9.4 To Resolve

The following properties apply to the block:

• country (Combine with language), language (DSSSL:language & D:country), & script (DSSSL:-none-)

  Replaced with xml:lang. Used for justification and hyphenation (Can extract from XML if the XML identifier is comprised of 2 or more tokens, each of which are 2 chars RFC-1766 (1995)).

• Need to evaluate RFC-1766 issues

3.10.1 Purpose

The character formatting object is used when one needs to explicitly override a specific character or array of characters with a specific glyph.

When the result tree is interpreted as a tree of formatting objects, a character in the result tree is treated as if it were an empty element of type fo:character with a char attribute equal to the character.

3.10.2 Formatting Object Summary

<fo:character

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

text-shadow (DSSSL:-none-, CSS:-same-) = see CSS

Value(s): {-TBD-...-TBD-}

Inherited, Initial = -TBD-

text-transform (DSSSL:-none-, CSS:-same-) = ( as-entered | lower | upper | title | (see CSS) )

Inherited, Initial = as-entered

/>

3.10.3 Formatting Object's Formal Specification

A character formatting object is atomic.

A character can only be inline.

A character is formatted to produce a single inline area. This may be merged with adjacent inline areas if the ligature property is true. The position-point of the inline area is the position-point of the glyph specified in the font resource for the specified writing-mode. The escapement direction is the direction between the position-point and escapement-points as specified in the font resource for the specified writing-mode. The size of the area in the inline-progression-direction is the distance between the position and escapement-points. [[Ed-Note: How does this deal with backgrounds when test is letterspaced or kerned?]] The size of the area before and after the placement-path in the shift-direction is the smallest that will enclose the extent of the glyph in those directions as specified in the font resource for the specified writing-mode. If the nominal alignment mode of the font resource for the character's writing-mode is not the same as the block's alignment mode, then the glyph area is automatically adjusted as specified by the alignment-mode in the font resource for the specified writing-mode.

3.10.4 To Resolve

The following properties apply to a character:

• char

• char-kern

• char-kern-mode

• char-ligature

• color (DSSSL:-same-)

• font-specification (to be supplied in future Drafts)

• glyph-alignment-mode (DSSSL:-same-, CSS:-none-) Non-core

• hyphenate

• hyphenation-char (DSSSL:-same-, CSS:-none-)

• inhibit-wrap

• language (DSSSL:language & D:country)

• position-point-shift

• letterspace-after-maximum (DSSSL:inline-space-after, CSS:letter-spacing)

• letterspace-after-minimum (DSSSL:inline-space-after, CSS:letter-spacing)

• letterspace-after-optimum (DSSSL:inline-space-after, CSS:letter-spacing)

• wordspacing-maximum (DSSSL:inline-space-space, CSS:word-spacing)

• wordspacing-minimum (DSSSL:inline-space-space, CSS:word-spacing)

• wordspacing-optimum (DSSSL:inline-space-space, CSS:word-spacing)

• text-shadow (DSSSL:-none-, CSS:-same-)

• text-transform (DSSSL:-none-, CSS:-same-) Add from CSS: capitalize | uppercase | lowercase | none

• writing-mode (DSSSL:-same-)

3.11.1 Purpose

A list is used to group all the items in a list.

A list may be nested within another list, and it is a block-level object.

Lists are useful for controlling the separation between preceding and following formatting objects through the space-before-minimum and space-after-minimum properties . They can be also used to specify the indent and margins for nested lists, and for controlling the break preferences. They also provide a mechanism for specifying and bracketing autonumbering sequences.

3.11.2 Formatting Object Summary

<fo:list

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

break-before = ( none | page | page-odd | page-even | Optional (Non-inherited), Default = none

NOTE: Complex mapping to CSS. Specifies whether a page, column, etc., should start before the list.

break-after = ( none | page | page-odd | page-even | Optional (Non-inherited), Default = none

NOTE: Complex mapping to CSS. Specifies whether a page, column, etc., should start after the list.

indent-start = length-specifier

Value(s): {0.0pt...available-width}

Inherited, Initial = 0.0pt

NOTE: Specifies the initial point of indentation for all members of the list.

indent-end = length-specifier

Value(s): {0.0pt...available-width}

Inherited, Initial = 0.0pt

NOTE: Specifies the final point of indentation for all members of the list. In a left to right writing direction languages, this is normally called right-indent.

space-before-maximum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted before the list in the block-progression-direction. Non-core

space-before-minimum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted before the list in the block-progression-direction. Non-core

space-before-optimum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted before the list in the block-progression-direction.

space-after-maximum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted after the list in the block-progression-direction. Non-core

space-after-minimum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted after the list in the block-progression-direction. Non-core

space-after-optimum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted after the list in the block-progression-direction.

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:list>

3.11.3 Formatting Object's Formal Specification

A list is a block-level flow object that contains one or more list-item objects.

Although a list can be nested inside another list, it cannot be a direct child; rather, it can be the child of a list's list-item-body.

3.12.1 Purpose

A list-item flow object contains the label and the body of each item; it may be used for overriding and modifying some of the list's properties on a case by case basis.

3.12.2 Formatting Object Summary

<fo:list-item

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

indent-start = length-specifier

Value(s): {0.0pt...available-width}

Inherited, Initial = 0.0pt

NOTE: Specifies the initial point of indentation for the whole list-item Overrides the value set in the list.

indent-end = length-specifier

Value(s): {0.0pt...available-width}

Inherited, Initial = 0.0pt

NOTE: Specifies the final point of indentation for the whole list-item Overrides the value set for the list.

item-space-before-maximum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted before each list item in the direction of the block-progression-direction. Usually specified at the list level. Note: This is a block-level space. Non-core

item-space-before-minimum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted before each list item in the direction of the block-progression-direction. Usually specified at the list level. Note: This is a block-level space.Non-core

item-space-before-optimum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted before each list item in the direction of the block-progression-direction. Usually specified at the list level. Note: This is a block-level space.

item-space-after-maximum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted after each list item in the direction of the block-progression-direction. Usually specified at the list level. Note: This is a block-level space. Non-core

item-space-after-minimum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted after each list item in the direction of the block-progression-direction. Usually specified at the list level. Note: This is a block-level space. Non-core

item-space-after-optimum = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space to be inserted after each list item in the direction of the block-progression-direction. Usually specified at the list level. Note: This is a block-level space.

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:list-item>

3.12.3 Formatting Object's Formal Specification

A list-item flow object can only be contained by a list. It is a wrapper for a list-item-label and an list-item-body. It controls their position relative to other items within the list. Most of its properties are typically specified on the list. It controls the position and padding of the label and the body within the list-item and in relation to other list-items in the list.

3.13.1 Purpose

A list-item-label is used to either enumerate, identify or adorn the list-item's body.

3.13.2 Formatting Object Summary

<fo:list-item-label

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

label-width = length-specifier

Value(s): {0.0pt...available-length}

Inherited, Initial = 0.0pt

NOTE: Specifies the amount of space, in the direction of the writing mode, to be reserved for the label. Typically set at the list level. [[Ed-Note: Check the issue of value=0]] If the value is 0, the formatter should calculate the width on the basis of the longest label in the list.

space-end = length-specifier

Value(s): {0.0pt...available-width}

Inherited, Initial = 0.0pt

NOTE: Note: Specifies the minimum space in the direction of the block-progression-direction between the label and the body's first line.

label-separator = length-specifier

Value(s): {-TBD-..-TBD-}

Inherited, Initial = 12.0pt

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:list-item-label>

3.13.3 Formatting Object's Formal Specification

A list-item-label can be contained only in a list-item. It can be used for enumerating the list-item. It can control the positioning of the label and its placement with respect tot he list-item-body. The label has content, and is formatted to become the adornment or enumeration of the list-item.

3.14.1 Purpose

The item-body flow object holds the components (usually blocks) for a list item.

It controls styling defaults for the body, the spacing between lines and between paras within the list item, break precedences for line and paragraphs within the list item.

3.14.2 Formatting Object Summary

<fo:list-item-body

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:list-item-body>

3.14.3 Formatting Object's Formal Specification

The item's body contains the content of the item, generally in the form of blocks.

3.15.1 Purpose

A rule-graphic is used to draw a graphic-line that is used to divide space on the page.

3.15.2 Formatting Object Summary

<fo:rule-graphic

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:rule-graphic>

3.15.3 Formatting Object's Formal Specification

3.15.4 To Resolve

A rule-graphics may be inline or block-level.

The following properties apply to the rule-graphic:

• color (DSSSL:-same-)

• block-level-alignment

• break-after (DSSSL:-same-)

• break-before (DSSSL:-same-)

• graphic-line-thickness (DSSSL:line-thickness)

• indent-end (DSSSL:end-indent, CSS:-object-margin-)

• indent-start (DSSSL:start-indent, CSS:-object-margin-)

• inhibit-wrap

• keep (DSSSL:-same-)

• keep-with-previous (DSSSL:-same-)

• keep-with-next (DSSSL:-same-)

• rule-graphic-length

• rule-graphic-orientation

• position-point-shift

• space-after-maximum (DSSSL:space-after) Non-core

• space-after-minimum (DSSSL:space-after) Non-core

• space-after-optimum (DSSSL:space-after)

• space-before-maximum (DSSSL:space-before) Non-core

• space-before-minimum (DSSSL:space-before) Non-core

• space-before-optimum (DSSSL:space-before)

• writing-mode (DSSSL:-same-)

3.16.1 Purpose

Holds an image or vector graphic.

Placement in XSL may be inline or block-level.

Content of the graphic may be instream or external (linked).

3.16.2 Formatting Object Summary

<fo:graphic

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:graphic>

3.16.3 Formatting Object's Formal Specification

3.16.4 To Resolve

The graphic formatting object is a formatting wrapper to hold graphic objects.

A graphic may be inline or block-level.

A graphic's content may be instream or external.

A graphic is not atomic.

The following properties apply to a graphic:

• inline

• block-level-alignment

• break-after (DSSSL:-same-)

• break-before (DSSSL:-same-)

• color (DSSSL:-same-)

• external-graphic-id

• graphic-max-height

• graphic-max-width

• graphic-scale

• indent-end (DSSSL:end-indent, CSS:-object-margin-)

• indent-start (DSSSL:start-indent, CSS:-object-margin-)

• inhibit-wrap

• keep (DSSSL:-same-)

• keep-with-previous (DSSSL:-same-)

• keep-with-next (DSSSL:-same-)

• position-point-x

• position-point-y

• position-preference (DSSSL:-same-)

• space-after-maximum (DSSSL:space-after) Non-core

• space-after-minimum (DSSSL:space-after) Non-core

• space-after-optimum (DSSSL:space-after)

• space-before-maximum (DSSSL:space-before) Non-core

• space-before-minimum (DSSSL:space-before) Non-core

• space-before-optimum (DSSSL:space-before)

• writing-mode (DSSSL:-same-)

3.17.1 Purpose

Highlights text. Used to produce underlines, strike-through, overbars, etc.

3.17.2 Formatting Object Summary

<fo:score

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:score>

3.17.3 Formatting Object's Formal Specification

3.17.4 To Resolve

This object holds its content as children.

The content is scored (a highlight or text decoration using a graphic line under, over, or through the text).

A score can contain only inline formatting objects.

The following properties apply to score:

• color (DSSSL:-same-)

• graphic-line-thickness (DSSSL:line-thickness)

• position-shift

• inhibit-wrap

• score-spaces

3.18.1 Purpose

Highlights text or graphics.

Used to produce borders and backgrounds.

Controls spacing surrounding the content.

3.18.2 Formatting Object Summary

<fo:inline-box

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:inline-box>

3.18.3 Formatting Object's Formal Specification

3.18.4 To Resolve

The following properties apply to the inline-box:

• box-reserve-space

• box-open-end

• box-size-after

• box-size-before

• box-type

• break-after (DSSSL:-same-)

• break-before (DSSSL:-same-)

• color (DSSSL:-same-)

• graphic-line-thickness (DSSSL:line-thickness)

• indent-end (DSSSL:end-indent, CSS:-object-margin-)

• indent-start (DSSSL:start-indent, CSS:-object-margin-)

• inhibit-textline-breaks?

• keep (DSSSL:-same-)

• keep-with-previous? (DSSSL:-same-)

• keep-with-next? (DSSSL:-same-)

• space-after-maximum (DSSSL:space-after) Non-core

• space-after-minimum (DSSSL:space-after) Non-core

• space-after-optimum (DSSSL:space-after)

• space-before-maximum (DSSSL:space-before) Non-core

• space-before-minimum (DSSSL:space-before) Non-core

• space-before-optimum (DSSSL:space-before)

• writing-mode (DSSSL:-same-)

3.19.1 Purpose

Highlights text or graphics.

Used to produce borders and backgrounds.

Controls spacing surrounding the content.

3.19.2 Formatting Object Summary

<fo:block-level-box

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:block-level-box>

3.19.3 Formatting Object's Formal Specification

3.19.4 To Resolve

The following properties apply to the block-level-box:

• box-reserve-space

• box-size-after

• box-size-before

• box-type

• break-after (DSSSL:-same-)

• break-before (DSSSL:-same-)

• color (DSSSL:-same-)

• graphic-line-thickness (DSSSL:line-thickness)

• indent-end (DSSSL:end-indent, CSS:-object-margin-)

• indent-start (DSSSL:start-indent, CSS:-object-margin-)

• inhibit-textline-breaks?

• keep (DSSSL:-same-)

• keep-with-previous? (DSSSL:-same-)

• keep-with-next? (DSSSL:-same-)

• space-after-maximum (DSSSL:space-after) Non-core

• space-after-minimum (DSSSL:space-after) Non-core

• space-after-optimum (DSSSL:space-after)

• space-before-maximum (DSSSL:space-before) Non-core

• space-before-minimum (DSSSL:space-before) Non-core

• space-before-optimum (DSSSL:space-before)

• writing-mode (DSSSL:-same-)

3.20.1 Purpose

This object is used to instruct the formatter to construct and present a page-number. (Page numbers can not be constructed by the XSL processor because it has no knowledge of the line-breaking or actual pagination, except in very limited cases.)

3.20.2 Formatting Object Summary

<fo:page-number

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

/>

3.20.3 Formatting Object's Formal Specification

3.20.4 To Resolve

Multiple numbering sequences. (Examples: Front matter, body+appendix; Front-matter, by-chapter, by-appendix)

Complex numbers (15-5)

See xsl:number for properties.

3.21.1 Purpose

A link formatting object creates an area that a user can select to request traversal to another resource. An XLink-aware processor may create these regions on its own, but that does not preclude a designer from creating additional links from contextual information in the document.

The link contains link-end-locator flow objects, which provide information about the destination or destinations of the link, as well as any renderable flow objects. The region of the link is coextensive with that of the renderable flow objects contained within it. A user agent may specify two modes of link selection: an informative one (such as hovering over the link with a mouse or tabbing to it) and an activating one (such as clicking on the link or pressing return). When the user selects the link for information, if there is only one link end, the content of that link end should be presented (in a tool tip, in the status bar, or any other means appropriate to the user agent); if there are multiple link ends, they may all be shown if the user agent has facility (such as a pop-up menu), or the user agent may simply indicate that multiple ends exist. When the user activates the link, a choice of link ends should be offered, using the renderable content of each link end. After the user makes a selection from that list, traversal can begin.

Since the link and its link-end-locators are created by the XSL processor, link selection does not need to be automated at user action time. For instance, to randomly select one of a number of possible link ends, the stylesheet would simply create a single-ended link, whose link-end-locator is drawn randomly from the document, and present the user with only that choice.

XLink's transcluding capabilities can be handled simply by processing the target.

3.21.2 Formatting Object Summary

<fo:link

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

merge-link-end-locators = ( true | false )

Optional (Non-inherited), Default = true

NOTE: Note: If this link formatting object occurs within another, and merge-link-end-locators is true, then the effect is the same as if the link-end-locators of the ancestor were also link-end-locators of this link. In other words, the link-end-locators of the ancestor and those of this link are potential destinations when the user selects this link. If merge-link-end-locators is false, then only the link-end-locators associated with this link are potential destinations from this link.

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:link>

3.21.3 Formatting Object's Formal Specification

The link formatting object simply defines the range of the selectable object. Any link-end-locator formatting objects contained within it, but not contained within any nested link formatting objects, are its applicable destinations. If the merge-link-end-locators characteristic is true, then the link-end-locators of this particular link, as well as those of its ancestor link (and any merged therewith) are applicable destinations when the user selects this link. If merge-link-end-locators is false, then only the link-end-locators specific to this link may be reached.

In a default stylesheet for XLink, an extended link group should create one link formatting object, while the locators should create link-end-locator formatting objects. A simple link should create a link formatting object and a link-end-locator formatting object. An XML IDREF element would also create a link and a link-end-locator.

3.22.1 Purpose

A link-end-locator formatting object identifies a resource which may be reached from its parent link formatting object. Its content is used to present the link-end-locator to the user, likely derived from the XLink title attribute.

See the description of link for more information.

3.22.2 Formatting Object Summary

<fo:link-end-locator

id (DSSSL:-none-, CSS:-none-) = id-specifier

Optional (Non-inherited), Default = none

background-attachment = ( scroll | fixed )

Inherited, Initial = scroll

background-color = a color-specifier or transparent

Inherited, Initial = transparent

background-image = a URI or none

Inherited, Initial = none

background-position-x = ( a length-specifier | left | center | right )

Value(s): {0..max-length}

Inherited, Initial = left

background-position-y = ( a length-specifier | top | middle | bottom )

Value(s): {0..max-length}

Inherited, Initial = top

background-repeat = ( no-repeat | repeat | repeat-x | repeat-y )

Inherited, Initial = repeat

href = ( XPointer )

Required

NOTE: The XPointer identifies the resource located by this link-end-locator. This may be taken directly from an attribute value (as for an XLink locator) or calculated (e.g., from an XML IDREF or from the content of a glossary reference).

show-content = ( true | false )

Optional (Non-inherited), Default = false

NOTE: Note: Typically, the content of the link-end-locator formatting object is only shown so that the user may select a destination for the link. However, in some circumstances the designer may wish to present the title of the link-end-locator as part of the document's initial presentation.

NOTE: The user may also provide any additional inheritable properties for use by the descendants of this object.

> ... </fo:link-end-locator>

3.22.3 Formatting Object's Formal Specification

When a user requests traversal of a link formatting object, the user agent should present a list of possible destinations (if there is more than one). The user agent may also offer an informative mode of interaction with a link, such as hovering over it with a mouse pointer. In those cases, the formatted content of the link-end-locator formatting object should be used to represent this potential destination.

A default stylesheet for XLink would create a link-end-locator for every locator element; it would also create both a link and a link-end-locator for simple links. Similarly, an XML IDREF would generate both a link and a link-end-locator; an xref to a chapter might create a link whose only content is a link-end-locator to that chapter, whose content in turn is the formatted title of the chapter, and whose show-content characteristic is set to true.