XHTML 2
XHTML 2
XHTML™ 2.0
W3C Working Draft 26 July 2006
This version:
http://www.w3.org/TR/2006/WD-xhtml2-20060726
Latest version:
http://www.w3.org/TR/xhtml2
Previous version:
http://www.w3.org/TR/2005/WD-xhtml2-20050527
Diff-marked version:
xhtml2-diff.html
Editors:
Jonny Axelsson, Opera Software
Mark Birbeck, x-port.net
Micah Dubinko, Invited Expert
Beth Epperson, Websense
Masayasu Ishikawa, W3C
Shane McCarron, Applied Testing and Technology
Ann Navarro, WebGeek, Inc.
Steven Pemberton, CWI (HTML Working Group Chair)
This document is also available in these non-normative formats: Single XHTML file [p.1] ,
PostScript version, PDF version, ZIP archive, and Gzip’d TAR archive.
Copyright ©2006 W3C ® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and
document use rules apply.
Abstract
XHTML 2 is a general-purpose markup language designed for representing documents for a
wide range of purposes across the World Wide Web. To this end it does not attempt to be all
things to all people, supplying every possible markup idiom, but to supply a generally useful set
of elements.
-1-
Quick Table of Contents XHTML™ 2.0
http://www.w3.org/TR/.
This document is the eighth public Working Draft of this specification. It should in no way be
considered stable, and should not be normatively referenced for any purposes whatsoever. This
version includes an early implementation of XHTML 2.0 in RELAX NG [RELAXNG [p.247] ], but
does not include the implementations in DTD or XML Schema form. Those will be included in
subsequent versions, once the content of this language stabilizes.
This document has been produced by the W3C HTML Working Group (members only) as part of
the W3C HTML Activity. The goals of the HTML Working Group are discussed in the HTML
Working Group charter.
This document was produced by a group operating under the 24 January 2002 CPP as
amended by the W3C Patent Policy Transition Procedure. W3C maintains a public list of any
patent disclosures made in connection with the deliverables of the group; that page also
includes instructions for disclosing a patent. An individual who has actual knowledge of a patent
which the individual believes contains Essential Claim(s) must disclose the information in
accordance with section 6 of the W3C Patent Policy.
Publication as a Working Draft does not imply endorsement by the W3C Membership. This is a
draft document and may be updated, replaced or obsoleted by other documents at any time. It is
inappropriate to cite this document as other than work in progress.
-2-
XHTML™ 2.0 List of Issues
List of Issues
1. [PR #7759] [XHTML2] Spirit of "1.1.3. XHTML 2 and Presentation"
2. [PR #7723] On introducing a fallback attribute
3. [PR #7777] [XHTML 2] Conforming documents and meta properties
4. [PR #7791] Fw: [XHTML 2] Section 3.1.1
5. [PR #7804] Comments on XHTML 2.0 document conformance requirements
6. [PR #7808] Change XHTML 2.0 namespace to http://www.w3.org/1999/xhtml
7. [PR #7818] Namespace versioning problem in XHTML 2
8. [PR #7819] Referance XML 1.1 and example with XML 1.1 declaration
9. [PR #7336] Identifying XHTML version in ansence of DTDs
-3-
List of Issues XHTML™ 2.0
-4-
XHTML™ 2.0 Full Table of Contents
-5-
Full Table of Contents XHTML™ 2.0
8.10. Issues . . . . . . . . . . . . . . . . . 49
.
9. XHTML Text Module . . . . . . . . . . . . . . . . 51
.
9.1. The abbr element . . . . . . . . . . . . . . . 52
.
9.2. The cite element . . . . . . . . . . . . . . . 52
.
9.3. The code element . . . . . . . . . . . . . . . 53
.
9.4. The dfn element . . . . . . . . . . . . . . . 53
.
9.5. The em element . . . . . . . . . . . . . . . 53
.
9.6. The kbd element . . . . . . . . . . . . . . . 54
.
9.7. The l element . . . . . . . . . . . . . . . . 54
.
9.8. The q element . . . . . . . . . . . . . . . . 55
.
9.9. The samp element . . . . . . . . . . . . . . . 55
.
9.10. The span element . . . . . . . . . . . . . . 56
.
9.11. The strong element . . . . . . . . . . . . . . 56
.
9.12. The sub element . . . . . . . . . . . . . . . 56
.
9.13. The sup element . . . . . . . . . . . . . . . 57
.
9.14. The var element . . . . . . . . . . . . . . . 57
.
9.15. Issues . . . . . . . . . . . . . . . . . 58
.
10. XHTML Hypertext Module . . . . . . . . . . . . . . 59
.
10.1. The a element . . . . . . . . . . . . . . . . 59
.
11. XHTML List Module . . . . . . . . . . . . . . . . 61
.
11.1. Definition lists: the dl, di, dt, and dd elements . . . . . . . . 62
.
11.2. The nl element . . . . . . . . . . . . . . . 63
.
11.3. The ol and ul elements . . . . . . . . . . . . . 64
.
11.4. The li element . . . . . . . . . . . . . . . 64
.
11.5. The label element . . . . . . . . . . . . . . 65
.
11.6. Issues . . . . . . . . . . . . . . . . . 65
.
12. XHTML Core Attributes Module . . . . . . . . . . . . . 67
.
12.1. Core Attribute Collection . . . . . . . . . . . . . 67
.
12.2. Issues . . . . . . . . . . . . . . . . . 69
.
13. XHTML Hypertext Attributes Module . . . . . . . . . . . . 71
.
13.1. Hypertext Attribute Collection . . . . . . . . . . . . 71
.
13.2. Issues . . . . . . . . . . . . . . . . . 75
.
14. XHTML I18N Attribute Module . . . . . . . . . . . . . 77
.
14.1. I18N Attribute Collection . . . . . . . . . . . . . 77
.
14.2. Issues . . . . . . . . . . . . . . . . . 78
.
15. XHTML Access Module . . . . . . . . . . . . . . . 79
.
15.1. The access element . . . . . . . . . . . . . . 79
.
16. XHTML Bi-directional Text Attribute Module . . . . . . . . . . 81
.
16.1. Bi-directional Text Collection . . . . . . . . . . . . 81
.
16.1.1. Inheritance of text direction information . . . . . . . . 81
.
16.1.2. The effect of style sheets on bidirectionality . . . . . . . 82
.
16.2. Issues . . . . . . . . . . . . . . . . . 83
.
17. XHTML Edit Attributes Module . . . . . . . . . . . . . 85
.
-6-
XHTML™ 2.0 Full Table of Contents
-7-
Full Table of Contents XHTML™ 2.0
-8-
XHTML™ 2.0 Full Table of Contents
-9-
Full Table of Contents XHTML™ 2.0
- 10 -
XHTML™ 2.0 1. Introduction
1. Introduction
This section is informative.
As generic XML as possible: if a facility exists in XML, try to use that rather than duplicating
it.
Less presentation, more structure: use style sheets for defining presentation.
More usability: within the constraints of XML, try to make the language easy to write, and
make the resulting documents easy to use.
More accessibility: some call it ’designing for our future selves’ – the design should be as
inclusive as possible.
Better internationalization: since it is a World Wide Web.
More device independence: new devices coming online, such as telephones, PDAs, tablets,
televisions and so on mean that it is imperative to have a design that allows you to author
once and render in different ways on different devices, rather than authoring new versions
of the document for each type of device.
Less scripting: achieving functionality through scripting is difficult for the author and restricts
the type of user agent you can use to view the document. We have tried to identify current
typical usage, and include those usages in markup.
Integration with the Semantic Web: make XHTML2 amenable for processing with semantic
web tools.
- 11 -
1.2. Major Differences with XHTML 1 XHTML™ 2.0
version of browsers before being able to use the new facilities, some parts of XHTML 2,
principally XForms and XML Events, still require user agents that understand that functionality.
A variety of W3C and other efforts, most notably [XLINK [p.249] ], attempted to create a
grammar for defining the characteristings of linking. Unfortunately, these grammars all fall short
of the requirements of XHTML. The community is continuing in its efforts to create a
comprehensive grammar that describes link characteristics.
The HTML Working Group has determined that such a grammar, while generally useful, is not
required for the definition of XHTML 2. Instead, this document is explicit in the characteristics of
the elements and attributes that are used to connect to other resources. The Working Group has
taken this course because 1) the problem with XHTML 2 is well bounded, 2) the general solution
is slow in coming, and 3) it will be easier for implementors to support and users to rely upon.
- 12 -
XHTML™ 2.0 1.2. Major Differences with XHTML 1
sections of a text from each other. In retrospect, the name hr (for horizontal rule) was
misleading, because an hr was neither necessarily horizontal (in vertical text it was
vertical), nor necessarily a rule (books often use other typographical methods such as a
line of three asterisks to represent separators, and style sheets can be used to give you
this freedom). In order to emphasize its structuring nature, to make it more widely
usable, and to make it clearer that it has no essential directionality, hr has been
renamed separator [p.48] .
Line breaks: in previous versions of HTML, the br element was used to add
micro-structure to text, essentially breaking a piece of text into several ’lines’. This
micro-structure is now made explicit in XHTML 2 with the l [p.54] element, which
encloses the text to be broken. Amongst other advantages, this gives more
presentational opportunities, such as the ability to automatically number lines, or to
color alternate lines differently.
Paragraph structure: in earlier versions of HTML, a p [p.46] element could only contain
simple text. It has been improved to bring it closer to what people perceive as a
paragraph, now being allowed to include such things as lists and tables.
Navigation lists: Part of the design of XHTML 2 has been to observe existing use of HTML
and identify what is perceived as missing, for instance by use of scripting to achieve ends
not supported directly in HTML. One obvious component of very many HTML pages is the
’navigation list’, consisting of a collection of links to other parts of the site, presented
vertically, horizontally, or as a drop-down menu. To support this type of usage, XHTML 2
introduces the navigation list element nl [p.63] , which codifies such parts of documents,
and allows different presentational idioms to be applied. An additional advantage is for
assistive technologies, that can allow the user to skip such elements.
Images: the HTML img element has many shortcomings: it only allows you to specify a
single resource for an image, rather than offering the fallback opportunities of the object
[p.121] element; the only fallback option it gives is the alt text, which can only be plain text,
and not marked up in any way; the longdesc attribute which allows you to provide a long
description of the image is difficult to author and seldom supported.
XHTML 2 takes a completely different approach, by taking the premise that all images have
a long description and treating the image and the text as equivalents. In XHTML 2 any
element may have a src [p.88] attribute, which specifies a resource (such as an image) to
load instead of the element. If the resource is unavailable (because of network failure,
because it is of a type that the browser can’t handle, or because images have been turned
off) then the element is used instead. Essentially the longdesc has been moved into the
document, though this behavior also mimicks the fallback behavior of the object [p.121]
element. (To achieve the tooltip effect that some browsers gave with the alt attribute, as in
HTML 4 you use the title [p.69] attribute).
Type: in HTML 4, the srctype [p.88] attribute when referring to an external resource was
purely a hint to the user agent. In XHTML 2 it is no longer a hint, but specifies the type(s) of
resource the user agent must accept.
Tables: the content model of tables has been cleaned up and simplified, while still allowing
the same functionality.
Bi-directional text: rather than use an explicit element to describe bi-directional override,
- 13 -
1.2. Major Differences with XHTML 1 XHTML™ 2.0
new values have been added to the dir [p.81] attribute that allow bi-directional override on
any element.
Edit: rather than use explicit ins and del elements to mark changes in a document, an
attribute edit [p.85] may be used on any element for the same purpose.
Linking: In HTML 3, only a [p.59] elements could be the source and target of hyperlinks. In
HTML 4 and XHTML 1, any element could be the target of a hyperlink, but still only a [p.59]
elements could be the source. In XHTML 2 any element can now also be the source of a
hyperlink, since href [p.71] and its associated attributes may now appear on any element.
So for instance, instead of <li><a href="home.html">Home</a></li>, you can now
write <li href="home.html">Home</li>. Even though this means that the a [p.59]
element is now strictly-speaking unnecessary, it has been retained.
Metadata: the meta [p.103] and link [p.101] elements have been generalized, and their
relationship to RDF [RDF [p.249] ] described. Furthermore, the attributes on these two
elements can be more generally applied across the language.
Role: in order to aid adding semantics to documents, the role attribute has been added,
along with an initial set of useful values, in order to classify the use of a particular element.
For instance a paragraph may play the role of a note, and so may be marked up <p
role="note">.
Events: event handling in HTML was restricted in several ways: since the event names
were hard-wired in the language (such as onclick), the only way to add new events was
to change the language; many of the events (such as click) were device-specific, rather
than referring to the intent of the event (such as activating a link); you could only handle an
event in one scripting language — it was not possible to supply event handlers in the same
document for several different scripting languages.
XHTML 2 uses XML Events [XMLEVENTS [p.249] ] to specify event handling, giving greater
freedom in the ability to handle events. Along with this, the script element has been
renamed handler to indicate its different semantics.
Forms: HTML Forms were introduced in 1993, before the advent of the e-commerce
revolution. Now with more than a decade of experience with their use, they have been
thoroughly overhauled and updated to meet the needs of modern forms, in the shape of
XForms [XFORMS [p.248] ], which are an integral part of XHTML 2.
Ownership where due: since HTML 4 was a standalone application, it defined many things
which no longer need to be defined now that it is an XML application. For instance the
definitions of whitespace are given by XML for input, and CSS for output; similarly, the
definition of values of the media [p.137] attribute are relegated to the relevant style sheet
language.
Frames and Framesets: In HTML 4 multi-panel "pages" could be described using the
frameset and frame elements. The Frames model is no longer defined in XHTML.
Instead, if is defined through the separate [XFRAMES [p.249] ] specification.
- 14 -
XHTML™ 2.0 1.3. What are the XHTML 2 Modules?
The modules defined in this specification are largely extensions of the modules defined in
XHTML Modularization 1.0. This specification also defines the semantics of the modules it
includes. So, that means that unlike earlier versions of XHTML that relied upon the semantics
defined in HTML 4 [HTML4 [p.249] ], all of the semantics for XHTML 2 are defined either in this
specification or in the specifications that it normatively references.
Even though the XHTML 2 modules are defined in this specification, they are available for use in
other XHTML family markup languages. Over time, it is possible that the modules defined in this
specification will migrate into the XHTML Modularization specification.
1.4. Issues
[XHTML2] Spirit of "1.1.3. XHTML 2 and Presentation" PR #7759
State: Suspended
Resolution: None
User: None
Notes:
Suspended until last call
- 15 -
1.4. Issues XHTML™ 2.0
- 16 -
XHTML™ 2.0 2. Terms and Definitions
While some terms are defined in place, the following definitions are used throughout this
document. Familiarity with the W3C XML 1.0 Recommendation [XML [p.248] ] is highly
recommended.
abstract module
a unit of document type specification corresponding to a distinct type of content,
corresponding to a markup construct reflecting this distinct type.
content model
the declared markup structure allowed within instances of an element type. XML 1.0
differentiates two types: elements containing only element content (no character data) and
mixed content (elements that may contain character data optionally interspersed with child
elements). The latter are characterized by a content specification beginning with the
"#PCDATA" string (denoting character data).
deprecated
a feature marked as deprecated is in the process of being removed from this
recommendation. Portable documents should not use features marked as deprecated.
document model
the effective structure and constraints of a given document type. The document model
constitutes the abstract representation of the physical or semantic structures of a class of
documents.
document type
a class of documents sharing a common abstract structure. The ISO 8879 [SGML [p.248] ]
definition is as follows: "a class of documents having similar characteristics; for example,
journal, article, technical manual, or memo. (4.102)"
document type definition (DTD)
a formal, machine-readable expression of the XML structure and syntax rules to which a
document instance of a specific document type must conform; the schema type used in
XML 1.0 to validate conformance of a document instance to its declared document type.
The same markup model may be expressed by a variety of DTDs.
driver
a generally short file used to declare and instantiate the modules of a DTD. A good rule of
thumb is that a DTD driver contains no markup declarations that comprise any part of the
document model itself.
element
an instance of an element type.
element type
the definition of an element, that is, a container for a distinct semantic class of document
content.
entity
an entity is a logical or physical storage unit containing document content. Entities may be
composed of parseable XML markup or character data, or unparsed (i.e., non-XML,
possibly non-textual) content. Entity content may be either defined entirely within the
- 17 -
2. Terms and Definitions XHTML™ 2.0
document entity ("internal entities") or external to the document entity ("external entities"). In
parsed entities, the replacement text may include references to other entities.
entity reference
a mnemonic string used as a reference to the content of a declared entity (e.g., "&" for
"&", "<" for "<", "©" for "©".)
facilities
Facilities are elements, attributes, and the semantics associated with those elements and
attributes.
focusable
Elements are considered "focusable" if they are visible (e.g., have the equivalent of the
[CSS2 [p.247] ] property of "display" with a value other than none) not disabled (see
[XFORMS [p.248] ]), and either 1) have an href [p.71] attribute or 2) are considered a form
control as defined in [XFORMS [p.248] ].
fragment identifier
A portion of a [URI [p.248] ] as defined in RFC 3986.
generic identifier
the name identifying the element type of an element. Also, element type name.
hybrid document
A hybrid document is a document that uses more than one XML namespace. Hybrid
documents may be defined as documents that contain elements or attributes from hybrid
document types.
instantiate
to replace an entity reference with an instance of its declared content.
markup declaration
a syntactical construct within a DTD declaring an entity or defining a markup structure.
Within XML DTDs, there are four specific types: entity declaration defines the binding
between a mnemonic symbol and its replacement content; element declaration constrains
which element types may occur as descendants within an element (see also content
model); attribute definition list declaration defines the set of attributes for a given element
type, and may also establish type constraints and default values; notation declaration
defines the binding between a notation name and an external identifier referencing the
format of an unparsed entity.
markup model
the markup vocabulary (i.e., the gamut of element and attribute names, notations, etc.) and
grammar (i.e., the prescribed use of that vocabulary) as defined by a document type
definition (i.e., a schema) The markup model is the concrete representation in markup
syntax of the document model, and may be defined with varying levels of strict conformity.
The same document model may be expressed by a variety of markup models.
module
an abstract unit within a document model expressed as a DTD fragment, used to
consolidate markup declarations to increase the flexibility, modifiability, reuse and
understanding of specific logical or semantic structures.
modularization
an implementation of a modularization model; the process of composing or de-composing a
DTD by dividing its markup declarations into units or groups to support specific goals.
Modules may or may not exist as separate file entities (i.e., the physical and logical
- 18 -
XHTML™ 2.0 2. Terms and Definitions
structures of a DTD may mirror each other, but there is no such requirement).
modularization model
the abstract design of the document type definition (DTD) in support of the modularization
goals, such as reuse, extensibility, expressiveness, ease of documentation, code size,
consistency and intuitiveness of use. It is important to note that a modularization model is
only orthogonally related to the document model it describes, so that two very different
modularization models may describe the same document type.
parameter entity
an entity whose scope of use is within the document prolog (i.e., the external subset/DTD or
internal subset). Parameter entities are disallowed within the document instance.
parent document type
A parent document type of a hybrid document is the document type of the root element.
tag
descriptive markup delimiting the start and end (including its generic identifier and any
attributes) of an element.
unavailable resource
any resource that is referenced as a URI in an attribute, but that cannot be accessed for any
reason, is considered unavailable. Example reasons include, but are not limited to: network
unavailable, no resource available at the URI given, inability of the user agent to process
the type of resource, etc.
user agent
any software that retrieves and renders Strictly Conforming Documents for users. This may
include browsers, media players, plug-ins, and other programs — including assistive
technologies — that help in retrieving and rendering such documents. See also Conforming
User Agent.
- 19 -
2. Terms and Definitions XHTML™ 2.0
- 20 -
XHTML™ 2.0 3. Conformance Definition
3. Conformance Definition
This section is normative.
The keywords "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT", "SHOULD",
"RECOMMENDED", "MAY", and "OPTIONAL" in this document are to be interpreted as
described in [RFC2119 [p.248] ].
1. The document must conform to the constraints expressed in the schemas in Appendix B -
XHTML 2.0 RELAX NG Definition [p.171] , Appendix D - XHTML 2.0 Schema [p.227] and
Appendix F - XHTML 2.0 Document Type Definition [p.231] .
2. The local part of the root element of the document must be html.
3. The start tag of the root element of the document must explicitly contain an xmlns
declaration for the XHTML 2.0 namespace [XMLNS [p.249] ]. The namespace URI for
XHTML 2.0 is defined to be http://www.w3.org/2002/06/xhtml2/.
The start tag may also contain an xsi:schemaLocation [p.38] attribute that associates this
namespace with the XML Schema at the URI
http://www.w3.org/MarkUp/SCHEMA/xhtml2.xsd.
4. There should be a DOCTYPE declaration in the document prior to the root element. If
present, the public identifier included in the DOCTYPE declaration must reference the DTD
found in Appendix F [p.233] using its Public Identifier. The system identifier may be modified
appropriately.
- 21 -
3.2. XHTML 2 User Agent Conformance XHTML™ 2.0
Note that in this example, the XML declaration is included. An XML declaration like the one
above is not required in all XML documents. XHTML document authors should use XML
declarations in all their documents. XHTML document authors must use an XML declaration
when the character encoding of the document is other than the default UTF-8 or UTF-16 and no
encoding is specified by a higher-level protocol.
1. The user agent must parse and evaluate an XHTML 2 document for well-formedness. If the
user agent claims to be a validating user agent, it must also validate documents against a
referenced schema according to [XML [p.248] ].
2. When the user agent claims to support facilities defined within this specification or required
by this specification through normative reference, it must do so in ways consistent with the
facilities’ definition.
3. A user agent must only recognize attributes of type ID (e.g., the id or xml:id attribute on
most XHTML 2 elements) as fragment identifiers.
4. If a user agent encounters an element it does not recognize, it must continue to process the
content of that element. If this "unrecognized" element uses recognized attributes, those
attributes must be processed with their usual semantics.
- 22 -
XHTML™ 2.0 3.3. Issues
5. If a user agent encounters an attribute it does not recognize, it must ignore the entire
attribute specification (i.e., the attribute and its value).
6. If a user agent encounters an attribute value it doesn’t recognize, it must use the default
attribute value.
7. When rendering content, user agents that encounter characters or character entity
references that are recognized but not renderable should display the document in such a
way that it is obvious to the user that normal rendering has not taken place.
8. White space must be handled according to the rules of [XML [p.248] ]. All XHTML 2
elements preserve whitespace.
The user agent must use the definition from CSS for processing white space characters
[CSS3-TEXT [p.247] ].
9. In the absence of a style-sheet, including user agents that do not process style sheets, the
default visual presentation should be as if the user agent used the CSS style sheet
specified in Appendix H.
Note that this specification does not generally specify the behavior of conforming
implementations when presented with non-conforming documents. This is either defined by an
underlying specification (e.g., [XML [p.248] ]) or left to the implementor.
3.3. Issues
On introducing a fallback attribute PR #7723
State: Open
Resolution: None
User: None
Notes:
Notes:
Notes:
- 23 -
3.3. Issues XHTML™ 2.0
Notes:
Notes:
Notes:
Referance XML 1.1 and example with XML 1.1 declaration PR #7819
State: Open
Resolution: None
User: None
Notes:
- 24 -
XHTML™ 2.0 4. The XHTML 2.0 Document Type
The XHTML 2.0 document type is a fully functional document type with rich semantics. It is a
collection of XHTML-conforming modules (most of which are defined in this specification). The
Modules and their elements are listed here for information purposes, but the definitions in their
base documents should be considered authoritative. In the on-line version of this document, the
module names in the list below link into the definitions of the modules within the relevant version
of the authoritative specification.
- 25 -
4.1. Issues XHTML™ 2.0
4.1. Issues
Identifying XHTML version in ansence of DTDs PR #7336
State: Suspended
Resolution: Defer
User: None
Notes:
BAE F2F: for the present DTD’s are required for entity resolution. This is a tricky issue, and the
working group needs to resolve it quickly. We are asking for input from the Hypertext
Coordination Group and others in our quest to sort it out.
- 26 -
XHTML™ 2.0 5. Module Definition Conventions
This document defines a variety of XHTML modules and the semantics of those modules. This
section describes the conventions used in those module definitions.
An abstract definition [p.27] of the module’s elements, attributes, and content models, as
appropriate.
A sub-section for each element in the module; These sub-sections contain the following
components:
A brief description of the element,
A definition of each attribute or attribute collection [p.33] usable with the element, and
A detailed description of the behavior of the element, if appropriate.
Note that attributes are fully defined only the first time they are used in each module. After
that, only a brief description of the attribute is provided, along with a link back to the primary
definition.
element name
When an element is included in a content model, its explicit name will be listed.
content set
Some modules define lists of explicit element names called content sets. When a content
set is included in a content model, its name will be listed.
- 27 -
5.4. Content Models XHTML™ 2.0
expr ?
Zero or one instances of expr are permitted.
expr +
One or more instances of expr are required.
expr *
Zero or more instances of expr are permitted.
a , b
Expression a is required, followed by expression b.
a | b
Either expression a or expression b is required.
a - b
Expression a is permitted, omitting elements in expression b.
parentheses
When an expression is contained within parentheses, evaluation of any subexpressions
within the parentheses take place before evaluation of expressions outside of the
parentheses (starting at the deepest level of nesting first).
extending pre-defined elements
In some instances, a module adds attributes to an element. In these instances, the element
name is followed by an ampersand (&).
defining required attributes
When an element requires the definition of an attribute, that attribute name is followed by an
asterisk (*).
defining the type of attribute values
When a module defines the type of an attribute value, it does so by listing the type in
parentheses after the attribute name.
defining the legal values of attributes
When a module defines the legal values for an attribute, it does so by listing the explicit
legal values (enclosed in quotation marks), separated by vertical bars (|), inside of
parentheses following the attribute name. If the attribute has a default value, that value is
followed by an asterisk (*). If the attribute has a fixed value, the attribute name is followed
by an equals sign (=) and the fixed value enclosed in quotation marks.
- 28 -
XHTML™ 2.0 5.5. Attribute Types
In addition to these pre-defined data types, XHTML Modularization defines the following data
types and their semantics (as appropriate):
- 29 -
5.5. Attribute Types XHTML™ 2.0
The user agent must combine this list with its own list of acceptable media
types by taking the intersection, and then use the resulting list as the field
value of the accept request header when requesting the resource using
ContentTypes HTTP.
A user agent must imitate similar behavior when using other methods than
HTTP. For instance, when accessing files in a local filestore, <p
src="logo" srctype="image/png, image/jpeg"> might cause the
user agent first to look for a file logo.png, and then for logo.jpg.
If a value for the content type is not given, "*/*" must be used for its value.
For the current list of registered content types, please consult [MIMETYPES
[p.247] ].
Coordinates Comma separated list of Length [p.30] s used in defining areas.
Date and time information, as defined by the type dateTime in
Datetime
[XMLSCHEMA [p.249] ] except that the timezone part is required.
Name used as destination for results of certain actions, with legal values as
HrefTarget
defined by NMTOKEN [p.29] .
A language code. The values should conform to [RFC3066 [p.248] ] or its
LanguageCode
successors.
A comma-separated list of language ranges with optional q parameters, as
defined in section 14.4 of [RFC2616 [p.248] ] as the field value of the
LanguageCodes
Accept-Language request header. Individual language codes should
conform to [RFC3066 [p.248] ] or its successors.
Either a number, representing a number of pixels, or a percentage,
Length representing a percentage of the available horizontal or vertical space. Thus,
the value "50%" means half of the available space.
- 30 -
XHTML™ 2.0 5.6. Issues
5.6. Issues
Fw: [XHTML 2] Section 5.5 quality values. PR #7799
State: Open
Resolution: None
User: None
Notes:
Notes:
- 31 -
5.6. Issues XHTML™ 2.0
- 32 -
XHTML™ 2.0 6. XHTML Attribute Collections
Many of the modules in this document define the required attributes for their elements. The
elements in those modules may also reference zero or more attribute collections. Attribute
collections are defined in their own modules, but the meta collection "Common" is defined in this
section. The table below summarizes the attribute collections available.
- 33 -
6. XHTML Attribute Collections XHTML™ 2.0
- 34 -
XHTML™ 2.0 6.1. Issues
Each of the attributes defined in an XHTML attribute collection is available when its
corresponding module is included in an XHTML Host Language or an XHTML Integration Set
(see [XHTMLMOD [p.248] ]). In such a situation, the attributes are available for use on elements
that are NOT in the XHTML namespace when they are referenced using their
namespace-qualified identifier (e.g., xhtml:id). The semantics of the attributes remain the
same regardless of whether they are referenced using their qualified identifier or not. If both the
qualified and non-qualified identifier for an attribute are used on the same XHTML namespace
element, the behavior is unspecified.
6.1. Issues
[XHTML2] Constraining attribute relationship PR #7661
State: Suspended
Resolution: Defer
User: None
Notes:
- 35 -
6.1. Issues XHTML™ 2.0
- 36 -
XHTML™ 2.0 7. XHTML Document Module
The Document Module defines the major structural elements for XHTML. These elements
effectively act as the basis for the content model of many XHTML family document types. The
elements and attributes included in this module are:
This module is the basic structural definition for XHTML content. The html element acts as the
root element for all XHTML Family Document Types.
- 37 -
7.1. The html element XHTML™ 2.0
Attributes
The version attribute needs a machine processable format so that document processors
can reliably determine that the document is an XHTML Family conforming document.
Attributes
Example
- 38 -
XHTML™ 2.0 7.3. The title element
<head>
<title>My Life</title>
</head>
Attributes
The title [p.39] element is used to identify the document. Since documents are often consulted
out of context, authors should provide context-rich titles. Thus, instead of a title such as
"Introduction", which doesn’t provide much contextual background, authors should supply a title
such as "Introduction to Medieval Bee-Keeping" instead.
For reasons of accessibility, user agents must always make the content of the title [p.39]
element available to users. The mechanism for doing so depends on the user agent (e.g., as a
caption, spoken).
Example
<title>A study of population dynamics</title>
The title of a document is metadata about the document, and so a title like <title>About
W3C</title> is equivalent to <meta about="" property="title">About
W3C</meta>.
Attributes
- 39 -
7.4. The body element XHTML™ 2.0
Example
<body id="theBody">
<p>A paragraph</p>
</body>
- 40 -
XHTML™ 2.0 8. XHTML Structural Module
This module defines all of the basic text container elements, attributes, and their content models
that are structural in nature.
- 41 -
8. XHTML Structural Module XHTML™ 2.0
blockcode Common (PCDATA | Text [p.51] | Heading [p.43] | Structural [p.43] | List
[p.43] [p.34] [p.61] )*
blockquote Common (PCDATA | Text [p.51] | Heading [p.43] | Structural [p.43] | List
[p.44] [p.34] [p.61] )*
Common
div [p.44] (PCDATA | Flow [p.43] )*
[p.34]
Common
h [p.45] (PCDATA | Text [p.51] )*
[p.34]
Common
h1 [p.45] (PCDATA | Text [p.51] )*
[p.34]
Common
h2 [p.45] (PCDATA | Text [p.51] )*
[p.34]
Common
h3 [p.45] (PCDATA | Text [p.51] )*
[p.34]
Common
h4 [p.45] (PCDATA | Text [p.51] )*
[p.34]
Common
h5 [p.45] (PCDATA | Text [p.51] )*
[p.34]
Common
h6 [p.45] (PCDATA | Text [p.51] )*
[p.34]
Common (PCDATA | Text [p.51] | List [p.61] | blockcode [p.43] |
p [p.46]
[p.34] blockquote [p.44] | pre [p.47] | table [p.145] )*
Common
pre [p.47] (PCDATA | Text [p.51] )*
[p.34]
Common
section [p.47] (PCDATA | Flow [p.43] )*
[p.34]
separator Common
EMPTY
[p.48] [p.34]
The content model for this module defines some content sets:
- 42 -
XHTML™ 2.0 8.1. The address element
Heading
h [p.45] | h1 [p.45] | h2 [p.45] | h3 [p.45] | h4 [p.45] | h5 [p.45] | h6 [p.45]
Structural
address [p.43] | blockcode [p.43] | blockquote [p.44] | div [p.44] | link [p.101] | List [p.61] |
meta [p.103] | p [p.46] | pre [p.47] | handler [p.91] | section [p.47] | separator [p.48] | table
[p.145]
Flow
Heading [p.43] | Structural [p.43] | Text [p.51]
Attributes
Example
<address href="mailto:[email protected]">Webmaster</address>
Attributes
- 43 -
8.3. The blockquote element XHTML™ 2.0
Attributes
Attributes
For example, suppose you wish to make a presentation in XHTML, where each slide is enclosed
in a separate element. You could use a div [p.44] element, with a class [p.67] of slide:
- 44 -
XHTML™ 2.0 8.5. The heading elements
<body>
<h>The meaning of life</h>
<p>By Huntington B. Snark</p>
<div class="slide">
<h>What do I mean by "life"</h>
<p>....</p>
</div>
<div class="slide">
<h>What do I mean by "mean"?</h>
...
</div>
...
</body>
Attributes
There are two styles of headings in XHTML: the numbered versions h1 [p.45] , h2 [p.45] etc.,
and the structured version h [p.45] , which is used in combination with the section [p.47]
element.
There are six levels of numbered headings in XHTML with h1 [p.45] as the most important and
h6 [p.45] as the least.
Structured headings use the single h element, in combination with the section [p.47] element to
indicate the structure of the document, and the nesting of the sections indicates the importance
of the heading. The heading for the section is the one that is a child of the section element.
Example
<body>
<h>This is a top level heading</h>
<p>....</p>
<section>
<p>....</p>
<h>This is a second-level heading</h>
<p>....</p>
<h>This is another second-level heading</h>
<p>....</p>
</section>
<section>
<p>....</p>
- 45 -
8.6. The p element XHTML™ 2.0
The practice of skipping heading levels is considered to be bad practice. The series h1 h2 h1
is acceptable, while h1 h3 h1 is not, since the heading level h2 has been skipped.
In comparison with earlier versions of HTML, where a paragraph could only contain inline text,
XHTML2’s paragraphs represent the conceptual idea of a paragraph, and so may contain lists,
blockquotes, pre’s and tables as well as inline text. Note however that they may not contain
directly nested p [p.46] elements.
Attributes
Example
<p>Payment options include:
<ul>
<li>cash</li>
<li>credit card</li>
<li>luncheon vouchers.</li>
</ul>
</p>
- 46 -
XHTML™ 2.0 8.7. The pre element
Note that all elements in the XHTML family preserve their whitespace in the document, which is
only removed on rendering, via a style sheet, according to the rules of CSS [CSS3-TEXT [p.247]
]. This means that in principle any elements may preserve or collapse whitespace on rendering,
under control of a style sheet.
Attributes
poet
</pre>
poet
Note that while historically one use of the pre [p.47] element has been as a container for source
code, the blockcode [p.43] element is intended for that.
- 47 -
8.9. The separator element XHTML™ 2.0
Attributes
By representing the structure of documents explicitly using the section [p.47] and h [p.45]
elements gives the author greater control over presentation possibilities than the traditional
implicit structuring using numbered levels of headings. For instance, it is then possible to
indicate the nesting of sections by causing a border to be displayed to the left of sections.
Example
<body>
<h>Events</h>
<section>
<h>Introduction</h>
<p>....</p>
<h>Specifying events</h>
<p>...</p>
<section>
<h>Attaching events to the handler</h>
<p>...</p>
</section>
<section>
<h>Attaching events to the listener</h>
<p>...</p>
</section>
<section>
<h>Specifying the binding elsewhere</h>
<p>...</p>
</section>
</section>
</body>
Attributes
Example
- 48 -
XHTML™ 2.0 8.10. Issues
Example
<nl>
<lable>Navigation</label>
<li href="/">Home</li>
<li><separator/></li>
<li href="prev">Previous</li>
<li href="..">Up</li>
<li href="next">Next</li>
</nl>
8.10. Issues
[XHTML2] How are UAs to interpret <h> and <hx> elements? PR #7820
State: Open
Resolution: None
User: None
Notes:
[XHTML2] How are UAs to interpret <h> and <hx> elements? PR #7830
State: Open
Resolution: None
User: None
Notes:
Notes:
Notes:
Agreed - should change these to be Flow.
- 49 -
8.10. Issues XHTML™ 2.0
Notes:
You are correct - there is nothing but good taste to prevent people doing silly things. However,
we need better wording to clarify that the content model does indeed support bad taste.
- 50 -
XHTML™ 2.0 9. XHTML Text Module
This module defines all of the basic text container elements, attributes, and their content models
that are "inline level". Note that while the concept of "inline level" can be construed as a
presentation aspect, in this case it is intended to only have a semantic meaning.
Text
abbr [p.52] | cite [p.52] | code [p.53] | dfn [p.53] | em [p.53] | kbd [p.54] | link [p.101] | meta
[p.103] | object [p.121] | q [p.55] | ruby [p.133] | samp [p.55] | span [p.56] | strong [p.56] | var
[p.57] | XForms_Form_Controls [p.163]
- 51 -
9.1. The abbr element XHTML™ 2.0
Attributes
The content of the abbr [p.52] element specifies the abbreviated expression itself, as it would
normally appear in running text. The title [p.69] or full [p.52] attributes may be used to provide
the full or expanded form of the expression. Such an attribute should be repeated each time the
abbreviation is defined in the document.
Examples
<abbr title="Limited">Ltd.</abbr>
<abbr title="Abbreviation">abbr.</abbr>
<p>The <span id="w3c">World Wide Web Consortium</span> (<abbr full="#w3c">W3C</abbr>)
develops interoperable technologies (specifications, guidelines, software, and tools)
to lead the Web to its full potential. <abbr full="#w3c">W3C</abbr> is a forum for
information, commerce, communication, and collective understanding.</p>
Attributes
In the following example, the cite [p.52] element is used to reference the book from which the
quotation is taken:
- 52 -
XHTML™ 2.0 9.3. The code element
Attributes
Example
The Pascal statement <code>i := 1;</code> assigns the
literal value one to the variable <var>i</var>.
Attributes
Example
<p role="definition">
An <dfn id="def-acronym">acronym</dfn> is a word
formed from the initial letters or groups of letters of words in a
set phrase or series of words.
</p>
Attributes
- 53 -
9.6. The kbd element XHTML™ 2.0
Example
Do <em>not</em> phone before 9 a.m.
Attributes
Example
To exit, type <kbd>QUIT</kbd>.
Attributes
By retaining structure in text that has to be broken over lines, you retain essential information
about its makeup. This gives you greater freedom with styling the content. For instance, line
numbers can be generated automatically from the style sheet if needed.
- 54 -
XHTML™ 2.0 9.8. The q element
l:before {
position: relative;
left: -1em;
counter-increment: linenumber;
content: counter(linenumber);
}
Attributes
Visual user agents must not by default add delimiting quotation marks (as was the case for the q
element in earlier versions of XHTML and HTML). It is the responsibility of the document author
to add any required quotation marks, either directly in the text, or via a style sheet.
Attributes
- 55 -
9.10. The span element XHTML™ 2.0
Example
On starting, you will see the prompt <samp>$ </samp>.
Attributes
Attributes
Example
On <strong>Monday</strong> please put the rubbish out,
but <em>not</em> before nightfall!
- 56 -
XHTML™ 2.0 9.13. The sup element
Attributes
Example
H<sub >2</sub>O
Attributes
Many scripts (e.g., French) require superscripts or subscripts for proper rendering. The sub
[p.56] and sup [p.57] elements should be used to markup text in these cases.
Example
E = mc<sup>2</sup>
<span xml:lang="fr">M<sup>lle</sup> Dupont</span>
Attributes
Example
The parameter <var>ncols</var> represents
the number of colors to use.
- 57 -
9.15. Issues XHTML™ 2.0
9.15. Issues
PCData not in Text PR #7876
State: Open
Resolution: None
User: None
Notes:
The group agrees that we should change the abstract module definitions such that PCDATA is
just included in Text.
Notes:
The working group cannot come up with an example. Requesting one from the submitter.
RE: [ off list ] XHTML 2.0 - dfn : Content model and usability PR #7885
State: Open
Resolution: None
User: None
Notes:
- 58 -
XHTML™ 2.0 10. XHTML Hypertext Module
The Hypertext Module provides an element that traditionally has been used in HTML to define
hypertext links to other resources. Although all elements may now play the role of a hyperlink
(using the href [p.71] attribute) or hyperlink anchor (using the id [p.67] attribute), this element
remains for explicit markup of links, though is otherwise identical in semantics to the span [p.56]
element.
Attributes
Example
<a href="http://www.w3.org/">The W3C Home Page</a>
- 59 -
10.1. The a element XHTML™ 2.0
- 60 -
XHTML™ 2.0 11. XHTML List Module
As its name suggests, the List Module provides list-oriented elements. Specifically, the List
Module supports the following elements and attributes:
This module also defines the content set List with the content model (dl | nl | ol | ul)+ and adds
this set to the Flow [p.43] content set of the Structural [p.41] Module.
XHTML offers authors several mechanisms for specifying lists of information. Lists may contain:
Unordered information.
Ordered information.
Navigation information.
Definitions.
The previous list, for example, is an unordered list, created with the ul [p.64] element:
Example
<ul>
<li>Unordered information. </li>
<li>Ordered information. </li>
<li>Navigation information. </li>
<li>Definitions. </li>
</ul>
- 61 -
11.1. Definition lists: the dl , di , dt , and dd elements XHTML™ 2.0
An ordered list, created using the ol [p.64] element, contains information where order is
important, as in a recipe:
Definition lists, created using the dl [p.62] element, generally consist of a series of term/definition
pairs (although definition lists may have other applications). Thus, when advertising a product,
one might use a definition list:
Lower cost
The new version of this product costs significantly less than the previous one!
Easier to use
We’ve changed the product so that it’s much easier to use!
Safe for kids
You can leave your kids alone in a room with this product and they won’t get hurt (not a
guarantee).
Example
<dl>
<dt>Lower cost</dt>
<dd>The new version of this product costs significantly less than the
previous one!</dd>
<dt>Easier to use</dt>
<dd>We’ve changed the product so that it’s much easier to
use!</dd>
<dt>Safe for kids</dt>
<dd>You can leave your kids alone in a room with this product and
they won’t get hurt (not a guarantee).</dd>
</dl>
Definition lists vary only slightly from other types of lists in that list items consist of two parts: a
term and a description. The term is given by the dt [p.62] element. The description is given with
a dd [p.62] element. The term and its definition can be grouped within a di [p.62] element to help
clarify the relationship between a term and its definition(s).
- 62 -
XHTML™ 2.0 11.2. The nl element
Example
<dl>
<di>
<dt>Dweeb</dt>
<dd>young excitable person who may mature
into a <em>Nerd</em> or <em>Geek</em></dd>
</di>
<di>
<dt>Hacker</dt>
<dd>a clever programmer</dd>
</di>
<di>
<dt>Nerd</dt>
<dd>technically bright but socially inept person</dd>
</di>
</dl>
Example
<dl>
<dt>Center</dt>
<dt>Centre</dt>
<dd> A point equidistant from all points
on the surface of a sphere.</dd>
<dd> In some field sports, the player who
holds the middle position on the field, court,
or forward line.</dd>
</dl>
Navigation lists are intended to be used to define lists of selectable items for ordered
presentation. These may be presented in a number of ways, for instance as a navigation bar, or
as a menu. Note that a navigation list always starts with a label [p.65] element that defines the
label for the list.
- 63 -
11.3. The ol and ul elements XHTML™ 2.0
<nl>
<label>Contents </label>
<li href="#introduction">Introduction</li>
<li>
<nl>
<label>Terms</label>
<li href="#may">May</li>
<li href="#must">Must</li>
<li href="#should">Should</li>
</nl>
</li>
<li href="#conformance">Conformance</li>
<li href="#references">References</li>
...
</nl>
Both types of lists are made up of sequences of list items defined by the li [p.64] element. The
difference is that ol [p.64] lists represent lists of items that are essentially ordered (such as the
steps of a recipe), while ul [p.64] lists represent lists of items that are essentially unordered
(such as shopping lists).
- 64 -
XHTML™ 2.0 11.5. The label element
The li [p.64] element defines a list item within an ordered, unordered, or navigation list.
Within a list, each li element has an associated number, which is used for numbering list items
in ordered lists:
If the li element has a value attribute, the associated number is the value of that attribute;
otherwise, if the li element is the first in the list, then the number has the value 1;
otherwise the number is one higher than the number of the preceding li in the same list.
The label [p.65] element is used to define a label for a list. The contents of the label element
represent the title of a list (or sublist).
11.6. Issues
[XHTML2] 11.3. The ol , and ul elements PR #7663
State: Open
Resolution: None
User: None
Notes:
The working group is not in favor or the definition of a "continueFrom" attribute that would allow
continuation of list numbering, simply because there is no way to describe the behavior in
current styling languages. However, there is a usecase for being able to define groups of list
items and label them.... The working group is continuing to discuss this issue. To be *really* fair
to the required structure in his use case ... you really want something like this: <ol> <group>
<li>.. <li>... <li>... </group> <group> <label>... <li>... <li>... </group> </ol> The use case has two
different structures imposed on top of each other A bit like <label for=""> in HTML4
- 65 -
11.6. Issues XHTML™ 2.0
Notes:
- 66 -
XHTML™ 2.0 12. XHTML Core Attributes Module
The class [p.67] attribute can be used for different purposes in XHTML, for instance as a
style sheet [p.137] selector (when an author wishes to assign style information to a set of
elements), and for general purpose processing by user agents.
For instance in the following example, the p [p.46] element is used in conjunction with the
class [p.67] attribute to identify a particular type of paragraph.
Example
<p class="note">
These programs are only available if you have purchased
the advanced professional suite.
</p>
Style sheet rules can then be used to render the paragraph appropriately, for instance by
putting a border around it, giving it a different background color, or where necessary by not
displaying it at all.
It is good style to use names that represent the purpose of the element rather than the
visual presentation to be used. For instance don’t use class="red", but rather
class="urgent", or similar.
id = ID [p.29]
The id [p.67] attribute assigns an identifier to an element. The value of this attribute must be
unique within a document. This attribute MUST NOT be specified on an element in
conjunction with the xml:id [p.68] attribute.
- 67 -
12.1. Core Attribute Collection XHTML™ 2.0
Example
<h id="introduction">Introduction</h>
<p>...</p>
<h id="events">The Events Module</h>
<p>...</p>
xml:id = ID [p.29]
The xml:id [p.68] attribute assigns an identifier to an element. The value of this attribute
must be unique within a document. This attrinute MUST NOT be specified on an element in
conjunction with the id [p.67] attribute.
As an example, the following headings are distinguished by their xml:id [p.68] values:
Example
<h xml:id="introduction">Introduction</h>
<p>...</p>
<h xml:id="events">The Events Module</h>
<p>...</p>
layout = irrelevant*|relevant
This attribute allows authors to indicate whether the whitespace within an element is
relevant to the meaning of the content or not; for instance, visual user agents could display
the whitespace. The default is that it is irrelevant. Some elements, notably pre [p.47]
override this default. See whitespace handling in the section on XHTML Family User Agent
Conformance for more information.
Example
<p class="poem" layout="relevant">
(with wee ears and see?
tail frisks)
(gonE)
</p>
- 68 -
XHTML™ 2.0 12.2. Issues
Example
<a href="Jakob.html" title="Author biography">Jakob Nielsen</a>’s
Alertbox for January 11, 1998
12.2. Issues
attributes with no values PR #7872
State: Open
Resolution: None
User: None
Notes:
The working group intended this be NMTOKENS, and that an empty value be not permitted.
- 69 -
12.2. Issues XHTML™ 2.0
- 70 -
XHTML™ 2.0 13. XHTML Hypertext Attributes Module
The Hypertext Attributes Module defines the Hypertext [p.71] attribute collection. This collection
allows an element to be the start point of a hypertext link to a remote resource.
Example
cite="comments.html"
Actuation occurs as the default action of a [DOM [p.247] ] DOMActivate event for the
element on which the attribute occurs (for instance as the result of the user clicking on the
associated element). If elements contained within an element using an href [p.71] also use
an href [p.71] attribute, the User Agent must provide a mechanism for actuating any of
these "nested" URIs.
Example
<abbr href="http://www.w3.org/" title="World Wide Web">WWW</abbr>
<li href="contents.xhtml">contents</li>
<a href="http://www.cwi.nl/~steven/amsterdam.html">Amsterdam</a>
<quote href="hamlet.xhtml#p2435">To be or not to be</quote>
<var href="#index_ninc">ninc</var>
This attribute specifies the primary language of the resource designated by href [p.71] . At
its most general, it is a comma-separated list of language ranges with optional accept
parameters, as defined in section 14.4 of [RFC2616 [p.248] ] as the field value of the
Accept-Language request header.
In its simplest case, this is just a language code, such as "nl", but it may also contain variant
specifications such as "en-gb".
- 71 -
13.1. Hypertext Attribute Collection XHTML™ 2.0
The user agent must use this list as the field value of the accept-language request
header when requesting the resource using HTTP.
If this attribute is not present, the user agent must use its default value of the
accept-language request header.
Example
<p href="http://www.w3.org/2003/06/semantictour-pressrelease"
hreflang="fr">
The press release in French
</p>
Example
<p href="http://www.example.com/forPrinters.html"
hrefmedia="print">
A printable version of this page.
</p>
Example
<p href="http://www.w3.org"
hreftype="text/html,application/xhtml+xml">
The W3C Home Page
</p>
The sequence of focusable [p.18] elements is called the document’s navigation order. The
navigation order defines the order in which elements will receive focus when navigated by
the user. The navigation order may include elements nested within other elements.
- 72 -
XHTML™ 2.0 13.1. Hypertext Attribute Collection
3. If the fragment reference does not resolve in the document, the user agent must
ensure navigation starts at the beginning of the document.
2. If there is no reference to a fragment identifier when the document is loaded:
1. If the root element of the document has a nextfocus [p.72] attribute, and the
element referred to by the attribute is focusable, the element must receive focus.
The user agent must ensure the beginning of the element is visible on the display.
2. If the root element has no nextfocus [p.72] attribute, no element receives initial
focus. The user agent must ensure navigation starts at the beginning of the
document.
3. If the user has moved away from the initial navigation point of a document (e.g.,
through using page up and page down or by changing focus), refreshing the document
should result in the user’s navigation location being preserved.
In the event no element in the document has focus, when the user requests the next
focusable element, that element must be the next focusable element forward from the
current navigation point in document order. If there are no focusable elements before the
end of the document, focus shifts to the first focusable element in document order. If a
document has no focusable elements, then no element receives focus.
Once a focusable element in the document has focus, upon requesting that focus change to
the next focusable element, the user agent MUST follow these rules when determining
where focus is next set:
1. The next focus of an element without a nextfocus [p.72] attribute is the next focusable
[p.18] element in document order. If there are no remaining focusable [p.18] elements
in document order, the next focus must be on the first focusable [p.18] element in
document order.
2. The next focus of an element with a nextfocus [p.72] attribute is the element referenced
by that attribute if it is focusable [p.18] , otherwise the next focus of that element.
Regardless of the way in which an element receives focus, if the element is not currently
visible on the user agent’s display, the display must be updated so that the element is
visible.
The following example would allow the links to be navigated in column order (without the
use of nextfocus they would be navigated in document, i.e. row, order):
Example
<table>
<tr><td id="a" href="nw" nextfocus="b">NW</td>
<td id="c" href="ne" nextfocus="d">NE</td></tr>
<tr><td id="b" href="sw" nextfocus="c">SW</td>
<td id="d" href="se">SE</td></tr>
</table>
- 73 -
13.1. Hypertext Attribute Collection XHTML™ 2.0
Navigation keys. The actual key sequence that causes navigation or element activation
depends on the configuration of the user agent (e.g., the "tab" key might be used for
navigation and the "enter" key or "space" key used to activate a selected element).
In the event no element in the document has focus, when the user requests the previous
focusable [p.18] element, that element must be the next focusable element backward from
the current navigation point in document order. If there is no such focusable element back
to the start of the document, focus shifts to the last focusable element in document order. If
a document has no focusable elements, the behavior is unspecified.
Once a focusable element in the document has focus, upon requesting that focus change to
the previous focusable element, the user agent must do the following:
1. If the focused element has a prevfocus [p.74] attribute that references a focusable
element, focus is moved to that element.
2. Otherwise, focus shifts to the previous focusable element in document order.
3. If there are no previous focusable elements in document order, focus shifts to the last
focusable element in document order.
Regardless of the way in which an element receives focus, for visual user agents, if the
element is not currently visible on the user agent’s display, the display must be updated so
that the element is visible.
This specification does not define how this attribute gets used, since that is defined by the
environment that the hyperlink is actuated in. See for instance XFrames [XFRAMES [p.249]
]. However, values of this attribute that begin with the character ’_’ are reserved.
Example
<a href="home.html" target="main">Home</a>
- 74 -
XHTML™ 2.0 13.2. Issues
An element inherits URI base information according to the following order of precedence
(highest to lowest):
Example
See:
<ul xml:base="http://www.w3.org">
<li href="/" src="Icons/w3c_home">The W3C home page</li>
<li href="/TR">The W3C Technical Reports page</li>
<li href="/Markup">The HTML home page</li>
<li href="/Markup/Forms">The XForms home page</li>
</ul>
13.2. Issues
Fw: [XHTML 2] 13.1 Hypertext Attributes Module - nextfocus PR #7792
State: Approved
Resolution: None
User: None
Notes:
It is up to the document author to ensure that anchors in a document are appropriate for the
document’s audience. It would be inappropriate for a user agent to second guess the author’s
intent by adjusting focus to some parent element of the target. With regard to form fields and
incrementally loading user agents, the working group feels that it is unlikely a document’s fields
should be active before the document is done loading. Loading is complete when the DOMload
event fires - before that the user should not be able to interact with the document’s content - the
content may not have been properly prepared / initialized until after that.
- 75 -
13.2. Issues XHTML™ 2.0
- 76 -
XHTML™ 2.0 14. XHTML I18N Attribute Module
In this example, the default text-processing language of the document is French ("fr").
Within the first paragraph a single word is declared to be in English ("en"), after which the
primary language returns to French. The following paragraph is declared to be in English
and includes an embedded French word.
Example
<html xmlns="http://www.w3.org/2002/06/xhtml2" xml:lang="fr" ...>
<head>
<title>Un document multilingue</title>
</head>
<body>
<p>En janvier, toutes les boutiques de Londres
affichent des panneaux <span xml:lang="en">SALE</span>,
mais en fait ces magasins sont bien propres!</p>
<p xml:lang="en">Everwhere I went in France
the bakeries had signs up saying <em xml:lang="fr">PAIN</em>,
but despite that the bakers seemed quite happy.
</p>
</body>
</html>
- 77 -
14.2. Issues XHTML™ 2.0
14.2. Issues
Internationalization: translate attribute PR #7883
State: Open
Resolution: None
User: None
Notes:
- 78 -
XHTML™ 2.0 15. XHTML Access Module
access [p.79] Common [p.34] , key [p.79] , targetid [p.80] , targetrole [p.80] EMPTY
Attributes
Triggering an access key defined in an access element gives focus to the next element in
navigation order from the current focus that has the referenced role or id value. Note that it
is possible to associate additional event handlers with target which might then perform
additional actions once focus is changed.
The invocation of access keys depends on the implementation. For instance, on some
systems one may have to press the "alt" key in addition to the access key. On other
systems, one generally has to press the "cmd" key in addition to the access key.
The rendering of access keys depends on the user agent. We recommend that authors
include the access key in label text or wherever the access key is to apply. User agents
should render the value of an access key in such a way as to emphasize its role and to
distinguish it from other characters (e.g., by underlining it).
The Character assigned to a key, and its relationship to a role [p.131] or id [p.67] attribute,
are a suggestion of the author. User agents may provide mechanisms for overriding,
disabling, or re-assigning keys. In such user agents, user-specified assignments must take
precendence.
- 79 -
15.1. The access element XHTML™ 2.0
If no key attribute is specified, the user agent may assign an appropriate device mapping.
If a targetid [p.80] and a targetrole [p.80] are both specified for an element, the targetid [p.80]
attribute value must take precedence.
- 80 -
XHTML™ 2.0 16. XHTML Bi-directional Text Attribute Module
The Bi-directional Text module defines the Bi-directional [p.81] attribute collection.
rtl: Right-to-left text. The effect of this attribute is defined by the CSS2 rule:
*[dir="rtl"] { unicode-bidi: embed; direction: rtl}
lro: Left-to-right override. The effect of this attribute is defined by the CSS2 rule:
*[dir="lro"] { unicode-bidi: bidi-override; direction: ltr}
rlo: Right-to-left override. The effect of this attribute is defined by the CSS2 rule:
*[dir="rlo"] { unicode-bidi: bidi-override; direction: rtl}
Example
<p>
The Hebrew word for "Hebrew" is
<span xml:lang="he">עברית</span>,
but since Hebrew letters have intrinsic right-to-left directionality,
I had to type the word starting from the letter "ע",
i.e. <span xml:lang="he" dir="lro">עברית</span>.
</p>
- 81 -
16.1.2. The effect of style sheets on bidirectionality XHTML™ 2.0
When the dir [p.81] attribute is set for a block-level element, it remains in effect for the duration
of the element and any nested block-level elements. Setting the dir [p.81] attribute on a nested
element overrides the inherited value.
To set the base text direction for an entire document, set the dir [p.81] attribute on the html
[p.38] element.
Example
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 2.0//EN"
"http://www.w3.org/MarkUp/DTD/xhtml2.dtd">
<html xmlns="http://www.w3.org/2002/06/xhtml2/" dir="rtl">
<head>
<title><em>...a right-to-left title...</em></title>
</head>
<body>
<em>...right-to-left text...</em>
<p dir="ltr"><em>...left-to-right text...</em></p>
<p><em>...right-to-left text again...</em></p>
</body>
</html>
Inline-level elements, on the other hand, do not inherit the dir [p.81] attribute. This means that an
inline element without a dir [p.81] attribute does not open an additional level of embedding with
respect to the bidirectional algorithm.
When an inline-level element that does not have a dir [p.81] attribute is transformed to a
block-level element by a style sheet, it inherits the dir [p.81] attribute from its closest parent
block-level element to define the base direction of the block.
When a block-level element that does not have a dir [p.81] attribute is transformed to an
inline-level element by a style sheet, the resulting presentation should be equivalent, in terms of
bidirectional formatting, to the formatting obtained by explicitly adding a dir [p.81] attribute
(assigned the inherited value) to the transformed element.
- 82 -
XHTML™ 2.0 16.2. Issues
16.2. Issues
[XHTML 2] 15 Bi-directional text collection and embedded attributes? PR #7783
State: Open
Resolution: None
User: None
Notes:
- 83 -
16.2. Issues XHTML™ 2.0
- 84 -
XHTML™ 2.0 17. XHTML Edit Attributes Module
Example
<p>I will do it
next <span edit="deleted">week</span><span edit="inserted">month</span>.</p>
Example
datetime="2003-01-13T13:15:30Z"
- 85 -
17.1. Edit Collection XHTML™ 2.0
- 86 -
XHTML™ 2.0 18. XHTML Embedding Attributes Module
The Embedding Attributes module defines the Embedding [p.87] attribute collection.
This collection causes the contents of a remote resource to be embedded in the document in
place of the element’s content. If accessing the remote resource fails, for whatever reason
(network unavailable, no resource available at the URI given, inability of the user agent to
process the type of resource) or an associated ismap [p.96] attribute fails, the content of the
element must be processed instead.
Note that this behavior makes documents far more robust, and gives much better opportunities
for accessible documents than the longdesc attribute present in earlier versions of XHTML,
since it allows the description of the resource to be included in the document itself, rather than in
a separate document.
Example
<p src="holiday.png" srctype="image/png">
<span src="holiday.gif" srctype="image/gif">
An image of us on holiday.
</span>
</p>
The user agent must use this list as the field value of the accept-charset request header
when requesting the resource using HTTP.
If this attribute is not present, the user agent must use its default value of the accept-charset
request header.
- 87 -
18.2. Issues XHTML™ 2.0
User agents should use a similar technique when using other protocols that allow encoding
negotation
When using protocols that do not allow encoding negotiation to retrieve resources whose
encodings are not self-identifying, the user agent should use the first encoding in the
attribute’s value as the indication of the resource.
Example
<style type="text/css" src="style/home" encoding="utf-8" />
This attribute specifies the allowable content types of the resource referenced by the
relevant src [p.88] URI.
Example
<handler src="pop" srctype="application/x-javascript, text/x-newspeak" />
18.2. Issues
Re: Formal Response to My issue on styling embedding attributes. PR #7724
State: Open
Resolution: None
User: None
Notes:
Original message at: http://lists.w3.org/Archives/Public/www-html-editor/2005AprJun/0064 This
is a reply to issue 7655, where SP also replied
- 88 -
XHTML™ 2.0 18.2. Issues
Notes:
Notes:
Notes:
Notes:
Notes:
The 200 codes are classified as SUCCESS, so there should be no doubt. An empty document is
perfectly acceptable, so 204 is also a success 400 are all failures. 401: the HTTP req says the
reply SHOULD be shown to the user. It doesn’t say it has to be shown by embedding it at the
position where the URL was. It could be shown in a dialogue box, or a separate window.
Notes:
Add note to section that effect is defined in the datatype definition.
- 89 -
18.2. Issues XHTML™ 2.0
Notes:
Notes:
Notes:
Notes:
Notes:
Notes:
- 90 -
XHTML™ 2.0 19. XHTML Handler Module
The Handler Module defines elements that are used to contain information pertaining to event
handler implementations, usually defined in a scripting language. Elements and attributes
included in this module are:
When this module is used, the handler [p.91] element is added to the Structural [p.43] and Text
[p.51] content sets of the Structural [p.41] and Text [p.51] Modules. In addition, the handler
[p.91] element is added to the content model of the head [p.38] element defined in the
Document [p.37] Module.
The handler [p.91] element places one or more event handlers within a document. This element
may appear any number of times in the head [p.38] or body [p.39] of an XHTML document.
The handler may be defined within the contents of the handler [p.91] element or in an external
resource. If the src [p.88] attribute is not set, user agents must interpret the contents of the
element as the handler. If the src [p.88] has a URI value, user agents must ignore the element’s
contents and retrieve the handler via the URI. Note that the encoding [p.87] attribute refers to
the character encoding [p.29] of the handler designated by the src [p.88] attribute; it does not
concern the content of the handler [p.91] element.
- 91 -
19.1.2. Declaration of a handler language XHTML™ 2.0
A user agent must interpret a handler [p.91] element according to the following precedence
rules:
1. The user agent must first try to process the handler element, but not the embedded content.
2. If the user agent is not able to process the handler for any reason (configured not to, no
support of the indicated handler type, no access to an external resource, etc.), it must try to
process its contents.
3. If the content is a handler [p.91] element, its content should be processed according to
these rules.
4. Otherwise, it is evaluated as data of the handler type of the containing handler element.
In this example, we include one handler [p.91] in the header, whose handler is located in an
external file and is in the handler language "text/x-vbscript". The JavaScript code contained in
the inner handler [p.91] will be evaluated if and only if the user agent isn’t evaluating the outer
handler [p.91] . We also include one handler [p.91] in the body, which contains its own handler
written in "text/x-perl".
Example
<html xmlns="http://www.w3.org/2002/06/xhtml2" xml:lang="en">
<head>
<title>A document with a handler</title>
<handler type="text/x-vbscript" src="http://example.org/progs/vbcalc">
<handler type="text/javascript">
...some inline JavaScript...
</handler>
</handler>
</head>
<body>
<handler type="text/x-perl">
... some Perl script ...
</handler>
</body>
</html>
- 92 -
XHTML™ 2.0 20. XHTML Image Module
The Image Module provides basic image embedding, and may be used in some
implementations independently of client side image maps. The Image Module supports the
following element and attributes:
The img [p.93] element is a holder for embedding attributes such as src [p.88] . Since these
attributes may be applied to any element, the img [p.93] element is not strictly necessary, but is
included to ease the transition to XHTML2. Like the object [p.121] element, this element’s
content is only presented if the referenced resource is unavailable.
In the following example, the W3C logo would be presented if it were available. If it were
unavailable, then the enclosed text would be presented.
Example
<img src="W3C.png">W3C</img>
- 93 -
20.1. The img element XHTML™ 2.0
- 94 -
XHTML™ 2.0 21. XHTML Image Map Attributes Module
This collection adds attributes that specify that an embedded image may be used as an image
map, so that clicking on different parts of the image causes different hyperlinks to be activated.
Note that in the following example, if the image is unavailable for any reason, the fallback
properties of the src [p.88] attribute mean that the nl element will be displayed instead of the
image, thus making the page still useful:
Example
<html xmlns="http://www.w3.org/2002/06/xhtml2">
<head>
<title>The cool site!</title>
</head>
<body>
<p src="navbar1.png" srctype="image/png" usemap="#map1">
<nl id="map1">
<label>Navigate the site:</label>
<li href="guide.html" shape="rect"
coords="0,0,118,28">
Access Guide
</li>
<li href="shortcut.html" shape="rect"
coords="118,0,184,28">
Go
</li>
<li href="search.html" shape="circle"
coords="184,200,60">
Search
</li>
<li href="top10.html" shape="poly"
coords="276,0,276,28,100,200,50,50,276,0">
Top Ten
</li>
</nl>
</p>
</body>
</html>
Note that an li [p.64] in an nl [p.63] is not required to have an href [p.71] attribute. In that case,
the relevant region of the image is inactive.
Example
- 95 -
21.1. Image Map Attribute Collection XHTML™ 2.0
Note that W3C is working on profiles of XHTML that include versions of SVG [SVG [p.249] ],
which include more structured ways of creating imagemap-like behavior.
This attribute associates an image map with an nl [p.63] element. The value of usemap
should match the value of the id [p.67] attribute of an nl [p.63] element that contains one or
more li [p.64] elements with shape [p.97] and coords [p.97] attributes.
If accessing the URI fails or the referenced element is not an nl [p.63] element, then the
associated src [p.88] attribute is considered to have failed as well, so that the nested
content will be processed instead.
ismap = "ismap"
When an ismap attribute is specified, click events are not delivered to the embedded
resource, regardless of its type.
In the following example, the active region defines a server-side image map. A click
anywhere on the image will cause the click’s coordinates to be sent to the server.
<p href="http://www.example.com/cgi-bin/map"
src="map.png" ismap="ismap">
Our location.
</p>
The location clicked is passed to the server as follows. The user agent derives a new URI
from the URI specified by the href [p.71] attribute of the element, by appending ‘?’ followed
by the x and y coordinates, separated by a comma. The link is then actuated using the new
URI. For instance, in the given example, if the user clicks at the location x=10, y=27 then
the derived URI is "http://www.example.com/cgi-bin/map?10,27".
- 96 -
XHTML™ 2.0 21.1. Image Map Attribute Collection
User agents that do not offer the user a means to select specific coordinates (e.g.,
non-graphical user agents that rely on keyboard input, speech-based user agents, etc.)
must send the coordinates "0,0" to the server when the link is activated.
shape = "default|rect|circle|poly"
This attribute specifies the shape of a region. Possible values:
default: Specifies the entire region.
rect: Define a rectangular region.
circle: Define a circular region.
poly: Define a polygonal region.
Coordinates are relative to the top, left corner of the object. All values are of type Length
[p.30] . All values are separated by commas. The coordinates of the top, left corner of an
area are 0, 0.
- 97 -
21.1. Image Map Attribute Collection XHTML™ 2.0
- 98 -
XHTML™ 2.0 22. XHTML Media Attribute Module
Example
<style src="style.css" type="text/css" media="screen" />
<span src="photo.jpg" media="screen">Me at work</span>
<span src="photo-hires.jpg" media="print">Me at work</span>
- 99 -
22.1. Media Attribute Collection XHTML™ 2.0
- 100 -
XHTML™ 2.0 23. XHTML Metainformation Module
The Metainformation Module defines elements that allow the definition of relationships. These
may relate to:
Note that this module is dependent upon the Metainformation Attributes [p.113] module. The
attributes defined therein are available on the elements defined in this module, and their
semantics are the essential part of how these elements behave.
This element defines a link. Link [p.101] conveys relationship information that may be rendered
by user agents in a variety of ways (e.g., a tool-bar with a drop-down menu of links). User
agents should enable activation of links and the retrieval of link targets. Since link [p.101]
elements may have no content, information from the rel [p.115] and title [p.69] attributes should
be used when labelling links.
This example illustrates how several link [p.101] definitions may appear in the head [p.38]
section of a document. The current document is "Chapter2.html". The rel [p.115] attribute
specifies the relationship of the linked document with the current document. The values "Index",
"Next", and "Prev" are explained in the section on the attribute rel [p.115] .
- 101 -
23.1.1. Forward and reverse links XHTML™ 2.0
<head>
<title>Chapter 2</title>
<link rel="index" href="../index.html"/>
<link rel="next" href="Chapter3.html"/>
<link rel="prev" href="Chapter1.html"/>
</head>
Both the rel [p.115] and rev [p.117] attributes may be specified simultaneously.
The examples below illustrate how language information, media types, and link types may be
combined to improve document handling by search engines.
The following example shows how to use the hreflang [p.71] attribute to indicate to a search
engine where to find other language versions of a document. Note that for the sake of the
example the xml:lang [p.77] attribute has been used to indicate that the value of the title [p.69]
attribute for the link [p.101] element designating the French manual is in French.
<html ... xml:lang="en">
<head>
<title>The manual in English</title>
<link title="The manual in Dutch"
rel="alternate"
hreflang="nl"
href="http://example.com/manual/dutch.html"/>
<link title="La documentation en Français"
- 102 -
XHTML™ 2.0 23.2. The meta element
rel="alternate"
hreflang="fr" xml:lang="fr"
href="http://example.com/manual/french.html"/>
</head>
In the following example, we tell search engines where to find the printed version of a manual.
<head>
<title>Reference manual</title>
<link media="print"
title="The manual in PostScript"
hreftype="application/postscript"
rel="alternate"
href="http://example.com/manual/postscript.ps"/>
</head>
In the following example, we tell search engines where to find the front page of a collection of
documents.
<head>
<title>Reference manual -- Chapter 5</title>
<link rel="start" title="The first chapter of the manual"
hreftype="application/xhtml+xml"
href="http://example.com/manual/start.html"/>
</head>
The meta [p.103] element can be used to identify properties of a document (e.g., author,
expiration date, a list of key words, etc.) and assign values to those properties. This specification
defines a small normative set of properties, but users may extend this set as described for the
property [p.113] attribute.
Each meta [p.103] element specifies a property/value pair. The property [p.113] attribute
identifies the property and the content of the element or the value of the content [p.113] attribute
specifies the property’s value.
For example, the following declaration sets a value for the Author property:
Example
<meta property="dc:creator">Steven Pemberton</meta>
- 103 -
23.2.1. meta and search engines XHTML™ 2.0
Note. The meta [p.103] element is a generic mechanism for specifying metadata. However,
some XHTML elements and attributes already handle certain pieces of metadata and may be
used by authors instead of meta [p.103] to specify those pieces: the title [p.39] element, the
address [p.43] element, the edit [p.85] and related attributes, the title [p.69] attribute, and the cite
[p.71] attribute.
Note. When a property specified by a meta [p.103] element takes a value that is a URI [p.31] ,
some authors prefer to specify the metadata via the link [p.101] element. Thus, the following
metadata declaration:
Example
<meta property="dc:identifier">
http://www.rfc-editor.org/rfc/rfc3236.txt
</meta>
Example
<link rel="dc:identifier"
href="http://www.rfc-editor.org/rfc/rfc3236.txt" />
Example
<!-- For speakers of US English -->
<meta property="keywords"
xml:lang="en-us">vacation, Greece, sunshine</meta>
<!-- For speakers of British English -->
<meta property="keywords"
xml:lang="en">holiday, Greece, sunshine</meta>
<!-- For speakers of French -->
<meta property="keywords"
xml:lang="fr">vacances, Grèce, soleil</meta>
The effectiveness of search engines can also be increased by using the link [p.101] element to
specify links to translations of the document in other languages, links to versions of the
document in other media (e.g., PDF), and, when the document is part of a collection, links to an
appropriate starting point for browsing the collection.
- 104 -
XHTML™ 2.0 23.3. Literals and Resources
Example
this document was written on "March 21st, 2004"
This is not so useful though when trying to uniquely identify items that could occur in other
places. Take the example of the document’s author being "Mark Birbeck":
Example
this document was written by "Mark Birbeck"
Since there are other people called Mark Birbeck, then we won’t know which of them wrote
what. We get round this problem by allowing the value referred to, to be a URI. For example:
Example
this document was written by
<http://example.com/people/MarkBirbeck/654>
We distinguish these two types of properties by calling the first a ’string literal’ and the second a
’resource’.
NOTE: Of course there is nothing to stop two people from using this URI to identify two
completely different people. But in general URIs are accepted as a convenient way to identify a
specific item.
Example
<head>
<meta property="dc:creator">Mark Birbeck</meta>
<meta property="dc:created" content="2004-03-20" />
</head>
- 105 -
23.4.1. Literals XHTML™ 2.0
Example
this document has an ’author’ property of "Mark Birbeck";
this document has a ’created’ property of "2004-03-20".
Example
<head>
<meta property="dc:creator" content="Albert Einstein" />
<meta property="dc:title">E = mc<sup>2</sup>: The Most Urgent Problem
of Our Time</meta>
</head>
states that:
Example
this document has an ’author’ property of "Albert Einstein";
this document has a ’title’ property of
"E = mc<sup>2</sup>: The Most Urgent Problem of Our Time".
However, just because the mark-up is not processed as mark-up does not mean it need not be
well-formed and valid if the processor requires it.
Example
<head>
<meta property="height">87</meta>
</head>
In cases such as this it is not clear whether we are dealing with metres, miles or microns. Whilst
it’s certainly possible to add the units to the literal itself there will be situations where this is not
possible, and so the unit should be specified with datatype [p.113] In this example we use the
XML Schema type for date:
- 106 -
XHTML™ 2.0 23.4.2. Resources
Example
<head>
<meta property="created" datatype="xsd:date">2004-03-22</meta>
</head>
23.4.2. Resources
There will be situations when a string literal is not suitable as the value of a property. In the
example just given there would be no way to know which ’Mark Birbeck’ we are referring to. This
might not be a problem when documents are only used within one company, but this becomes a
big problem when documents are used across the internet.
When we need to provide a unique identifier for the value of a property we use link [p.101] . link
[p.101] identifies a relationship between one resource and another, and uses rel [p.115] to
indicate the nature of this relationship. In addition href [p.71] contains the URI that is being used
to uniquely identify the item being related to. For example:
Example
<head>
<link rel="author"
href="http://example.com/people/MarkBirbeck/654" />
</head>
Note that just because we are using URIs as unique identifiers doesn’t mean that navigating to
this URI with a web browser would yield anything useful. This is perhaps easier to see with the
following example:
Example
<head>
<link rel="source" href="urn:isbn:0140449132" />
</head>
To replace the term ’author’ with the more widely used Dublin Core term ’creator’, we would
need to not only substitute ’creator’ for ’author’, but also to indicate which list we are using. We
achieve the latter by using XML namespaces:
Example
- 107 -
23.5. Properties of Other Resources XHTML™ 2.0
<head xmlns:dc="http://purl.org/dc/elements/1.1/">
<meta property="dc:creator">Mark Birbeck</meta>
</head>
Example
this document has a property called ’creator’ (which comes
from a library of properties called the Dublin Core) and the
value of that property is the literal "Mark Birbeck".
Example
<html xmlns:dc="http://purl.org/dc/elements/1.1/">
<head>
<link about="#q1" rel="dc:source" href="urn:isbn:0140449132" />
</head>
<body>
<blockquote id="q1">
<p>
’Rodion Romanovitch! My dear friend! If you go on in this way
you will go mad, I am positive! Drink, pray, if only a few drops!’
</p>
</blockquote>
</body>
</html>
Note that the absence of about [p.113] does not always mean that the metadata refers to the
containing document. If the element containing metadata is a child of head [p.38] , then it does
relate to the document, and so the following mark-up:
Example
<head xmlns:dc="http://purl.org/dc/elements/1.1/">
<meta property="dc:creator">Mark Birbeck</meta>
</head>
- 108 -
XHTML™ 2.0 23.5.2. External Resources
Example
<head xmlns:dc="http://purl.org/dc/elements/1.1/">
<meta about="" property="dc:creator">Mark Birbeck</meta>
</head>
An example might be to say that the copyright of some document is owned by a company, and
further, that the company is located in London:
Example
<head xmlns:dc="http://purl.org/dc/elements/1.1/">
<link rel="dc:copyright"
href="http://example.com/company/OU true D
/showpage {OU {[Bb{Xl Yl Xh Yh}if Pn 0] ==} if showpage}d
/rlineto {OU {2 copy 1 3 array astore ==} if rlineto}d
/moveto {OU {2 copy 2 3 array astore ==} if moveto}d
/closepath {OU {[3] ==} if closepath}d
/setlinejoin {OU {1 copy 4 2 array astore ==} if setlinejoin}d
/restore {OU {[5] ==} if restore}d
/setrgbcolor {OU {3 copy 6 4 array astore ==} if setrgbcolor}d
/save {OU {[7] ==} if save}d
/fill {OU {[8] ==} if fill}d
/lineto {OU {2 copy 9 3 array astore ==} if lineto}d
/arc {OU {5 copy 10 6 array astore ==} if arc}d
/show {OU {1 copy 11 2 array astore ==} if show}d
/newpath {OU {[12] ==} if newpath}d
/stroke {OU {[13] ==} if stroke}d
/colorimage {OU {7 copy K 14 9 array astore ==} if colorimage}d
/awidthshow {OU {6 copy 15 7 array astore ==} if awidthshow}d
/rmoveto {OU {2 copy 16 3 array astore ==} if rmoveto}d
/image {OU {5 copy K 17 7 array astore ==} if image}d
/grestore {OU {[18] ==} if grestore}d
/setlinewidth {OU {1 copy 19 2 array astore ==} if setlinewidth}d
/rotate {OU {1 copy 20 2 array astore ==} if rotate}d
/translate {OU {2 copy 21 3 array astore ==} if translate}d
/scale {OU {2 copy 22 3 array astore ==} if scale}d
/gsave {OU {[23] ==} if gsave}d
/setgray {OU {1 copy 24 2 array astore ==} if setgray}d
/pdfmark {25] ==} D
/NF {OU{2 copy E 26 3 array astore ==}if ONF}d
/EX {[IS EC] ==} D
/Cd {} D
/DU {TU PM 1 eq and TP and{Pn ==}if}d
/BB {US Bb{dup Yl lt{dup /Yl E D}if dup Yh gt{/Yh E D}{pop}ie
dup Xl lt{dup /Xl E D}if dup Xh gt{/Xh E D}{pop}ie}
- 109 -
23.6. Chaining Metadata XHTML™ 2.0
property="dc:location">London</meta>
</head>
Example
<head xmlns:dc="http://purl.org/dc/elements/1.1/">
<link rel="dc:copyright"
href="http://example.com/company/OU true D
/showpage {OU {[Bb{Xl Yl Xh Yh}if Pn 0] ==} if showpage}d
/rlineto {OU {2 copy 1 3 array astore ==} if rlineto}d
/moveto {OU {2 copy 2 3 array astore ==} if moveto}d
/closepath {OU {[3] ==} if closepath}d
/setlinejoin {OU {1 copy 4 2 array astore ==} if setlinejoin}d
- 110 -
XHTML™ 2.0 23.6. Chaining Metadata
<meta property="dc:location">London</meta>
</link>
</head>
If resource is omitted from a link [p.101] then the nested metadata is still legitimate, it simply
relates to an anonymous resource. For example, we might want to say that the ’mother tongue’
of the author of Crime and Punishment is Russian, without saying anything further about the
author:
Example
<html xmlns:dc="http://purl.org/dc/elements/1.1/"
xmlns:con="http://example.org/terms/" >
<head />
<body>
<blockquote id="q1">
<link rel="dc:source" href="urn:isbn:0140449132">
<link rel="dc:creator">
<meta property="con:motherTongue">rus</meta>
</link>
</link>
<p>
’Rodion Romanovitch! My dear friend! If you go on in this way
you will go mad, I am positive! Drink, pray, if only a few drops!’
- 111 -
23.7. Issues XHTML™ 2.0
</p>
</blockquote>
</body>
</html>
When reading this metadata, the anonymous resource can be thought of simply as ’something’.
This mark-up means:
Note however that while placing further elements inside meta [p.103] is structurally valid, it does
not mean the same thing as the example we have just given, since the content of meta [p.103] is
an XML literal. The following:
Example
<blockquote id="q1">
<link about="#q1" rel="dc:source" href="urn:isbn:0140449132">
<meta property="dc:creator">
<meta property="con:motherTongue">rus</meta>
</meta>
</link>
<p>...</p>
</blockquote>
means that:
23.7. Issues
rebuild link element: chapter, section / subsection PR #7869
State: Open
Resolution: None
User: None
Notes:
- 112 -
XHTML™ 2.0 24. XHTML Metainformation Attributes Module
The Metainformation Attributes Module defines the Metainformation [p.113] attribute collection.
This collection allows elements to be annotated with metadata throughout an XHTML-family
document.
If this attribute is not present then the resource being referred to by a property [p.113]
attribute on the same element is decided as follows:
1. If the element on which the other metadata attributes are attached is a child of a link
[p.101] then the metadata inferred by the element concerns the URI referred to in the
link [p.101] .
2. Otherwise, the metadata inferred by the element concerns the current document.
Example
<meta about="http://www.example.com/" property="dc:created">2004-03-20</meta>
Example
<meta about="http://www.example.com/" property="dc:created" content="2004-03-20"/>
Example
<meta about="http://www.example.com/" property="dc:created" datatype="xsd:date">2004-03-20</meta>
Example
- 113 -
24.1. Metadata Attribute Collection XHTML™ 2.0
Authors may use the following properties, listed here with their conventional interpretations.
User agents, search engines, etc. are free to interpret these properties as necessary.
The list of predefined values (in the XHTML2 namesapce) are given below. Users may
extend this collection of relationships, however new values must be defined in their own
namespace, and the relationship names must be referenced in documents as qualified
names (e.g., dc:creator for the Dublin Core "creator" relationship).
Note that in order to reference relationship definitions via QName, their namespace must be
defined via an xmlns attribute somewhere suitable:
Example
<html .... xmlns:dc="http://purl.org/dc/elements/1.1/">
description
Gives a description of the resource.
generator
Identifies the software used to generate the resource.
keywords
Gives a comma-separated list of keywords describing the resource.
reference
The default value, gives no explicit information about the relationship with the resource.
robots
Gives advisory information intended for automated web-crawling software. This
specification does not define values for this property.
title
Specifies a title for the resource.
Note that previous versions of XHTML included an author property; this has now been
replaced with the Dublin Core creator property.
Note that:
Example
<head>
<title>My Life and Times</title>
Example
<head>
<meta property="title">My Life and Times</meta>
- 114 -
XHTML™ 2.0 24.1. Metadata Attribute Collection
Note that the title [p.69] attribute which is available on all XHTML2 elements, is just a
shorthand for a common case:
Example
<a href="Jakob.html" title="Author biography">Jakob Nielsen</a>’s Alertbox for January 11, 1998
is equivalent to:
Example
<meta about="#jakob" property="title">Author biography</meta>
<a href="Jakob.html" id="jakob">Jakob Nielsen</a>’s Alertbox for January 11, 1998
Note that this allows you to specify richer, marked-up text for a title when needed.
Example
<link href="top.html" rel="contents"/>
This example defines a link to a table of contents for the current document.
Example
<link href="doc.ps"
rel="alternate"
media="print"
hreftype="application/postscript" />
This example defines a link to an alternate version of the document especially suited to
printing.
Authors may use the following relationship names, listed here with their conventional
interpretations.
User agents, search engines, etc. may interpret these relationships in a variety of ways. For
example, user agents may provide access to linked documents through a navigation bar.
Users may extend this collection of relationships. However, extensions must be defined in
their own namespace, and the relationship names must be referenced in documents as
qualified names (e.g., dc:creator for the Dublin Core "creator" relationship).
Note that in order to reference relationship definitions via QName, their namespace must be
defined via an xmlns attribute somewhere suitable:
- 115 -
24.1. Metadata Attribute Collection XHTML™ 2.0
Example
<html .... xmlns:dc="http://purl.org/dc/elements/1.1/">
alternate
Designates alternate versions for the document. When used together with the hreflang
[p.71] attribute, it implies a translated version of the document. When used together
with the hrefmedia [p.72] attribute, it indicates a version intended for that type of device.
start
Refers to the first resource in a collection of resources. A typical use case might be a
collection of chapters in a book.
next
Refers to the next resource (after the current one) in an ordered collection.
prev
Refers to the previous resource (before the current one) in an ordered collection.
up
Refers to the resource "above" in a hierarchically structured set.
contents
Refers to a resource serving as a table of contents.
index
Refers to a resource providing an index.
glossary
Refers to a resource providing a glossary of terms.
copyright
Refers to a copyright statement for the resource.
chapter
Refers to a resource serving as a chapter in a collection.
section
Refers to a resource serving as a section in a collection.
subsection
Refers to a resource serving as a subsection in a collection.
appendix
Refers to a resource serving as an appendix in a collection.
help
Refers to a resource offering help (more information, links to other sources of
information, etc.)
bookmark
Refers to a bookmark. A bookmark is a link to a key entry point within an extended
document. The title [p.69] attribute may be used, for example, to label the bookmark.
Note that several bookmarks may be defined for a document.
meta
Refers to a resource that provides metadata, for instance in RDF.
icon
Refers to a resource that represents an icon.
p3pv1
Refers to a P3P Policy Reference File. See [P3P [p.247] ].
- 116 -
XHTML™ 2.0 24.1. Metadata Attribute Collection
profile
As a globally unique name. User agents may be able to recognize the name
(without actually retrieving the profile) and perform some activity based on known
conventions for that profile. For instance, search engines could provide an
interface for searching through catalogs of XHTML documents, where these
documents all use the same profile for representing catalog entries.
As a link. User agents may dereference the URI and perform some activity based
on the actual definitions within the profile (e.g., authorize the usage of the profile
within the current XHTML document). This specification does not define formats for
profiles.
This example refers to a hypothetical profile that defines useful properties for document
indexing. The properties defined by this profile -- including "author", "copyright",
"keywords", and "date" -- have their values set by subsequent meta [p.103]
declarations.
Example
<html ... xmlns:mp="http://www.example.com/profiles/rels">
<head>
<title>How to complete Memorandum cover sheets</title>
<link rel="profile" href="http://www.example.com/profiles/slideshow" />
</head>
<body>
<div class="slide">
some slide content...
</div>
</body>
...
role
Indicates the purpose of the resource. For some possible values, see the Role Attribute
[p.131] module.
cite
Refers to a resource that defines a citation (see cite [p.52] ) .
Example
- 117 -
24.2. Meta and RDF XHTML™ 2.0
This example states that the current document is the table of contents for the referenced
document.
The attributes rel [p.115] , rev [p.117] and property [p.113] represent predicates. The predicate is
obtained by concatenating the namespace URI and the local part of the QName of the attribute
value.
For attribute rel [p.115] , the subject is the about [p.113] property, and the object is the value of
the href [p.71] attribute; for attribute rev [p.117] , the subject and object roles are reversed: the
subject is the href [p.71] attribute, and the object is the value of the about [p.113] property.
For attribute property [p.113] , the subject is the about [p.113] property, and the object is the
string literal in the content [p.113] attribute, or otherwise the XML literal that is the content of the
element, decorated as necessary with the value of the datatype [p.113] attribute.
If the element that the attributes are on has an about [p.113] attribute, then that is used.
Otherwise for meta [p.103] and link [p.101] elements:
If the parent element has an explicit about [p.113] attribute, then that is the about
property.
Otherwise, if the parent element has an id [p.67] attribute, then that is the about
property.
Otherwise, the about property is a ’blank node’ representing the parent element (which
is like an invisible automatically generated id [p.67] on the element).
For all other elements, the about property is the closest about [p.113] attribute on an
ancestor of the current element. If there is no such attribute, it is the [URI [p.248] ] of the
containing document.
For example, articles often have the following repetitive structure, where the same values are
used for metadata properties and actual content rendered to the reader:
- 118 -
XHTML™ 2.0 24.3. Metadata as Content
Example
<html xmlns="http://www.w3.org/2002/06/xhtml2/"
xmlns:dc="http://purl.org/dc/elements/1.1/">
<head>
<title>... title ...</title>
<meta property="dc:date">2004-03-23</meta>
<meta property="dc:title">
High-tech rollers hit casino for £1.3m
</meta>
<meta property="dc:creator">Steve Bird</meta>
</head>
<body>
...
<span class="date">2004-03-23</span>
<span class="headline">
High-tech rollers hit casino for £1.3m
</span>
<span class="byline">By Steve Bird</span>
<span class="standfirst">
Word of a hand-held device which can beat the roulette wheel
has gambling bosses quaking
</span>
...
<p>...</p>
</body>
</html>
By making use of the meta attributes this can be shortened to the following:
Example
<html xmlns="http://www.w3.org/2002/06/xhtml2/"
xmlns:dc="http://purl.org/dc/elements/1.1/">
<head>
<title>... title ...</title>
</head>
<body>
...
<span property="dc:date"
class="date">
2004-03-23
</span>
<span property="dc:title"
class="headline">
High-tech rollers hit casino for £1.3m
</span>
By <span property="dc:creator"
class="byline">Steve Bird</span>
<span class="standfirst">
Word of a hand-held device which can beat the
roulette wheel has gambling bosses quaking
</span>
- 119 -
24.4. Mapping Lexical Content XHTML™ 2.0
...
<p>...</p>
</body>
</html>
This is often easier to maintain since an author editing their document is at the same time editing
the metadata.
Example
Tomorrow the <span>Prime Minister</span> is expected to fly to ...
However, by using href [p.71] and content [p.113] we can indicate exactly which Prime Minister
is being referred to, and when the journey is due to take place:
Example
<span content="2004-03-20">Tomorrow</span> the
<span href="http://example.com/people/TonyBlair/1">Prime Minister</span>
is expected to fly to ...
Note that if no property [p.113] is present then the example just given is equivalent to:
Example
<span property="reference"
content="2004-03-20">
Tomorrow
</span>
the <span property="reference"
href="http://example.com/people/TonyBlair/1">
Prime Minister
</span>
is expected to fly to ...
- 120 -
XHTML™ 2.0 25. XHTML Object Module
The Object Module provides elements for general-purpose object inclusion; this includes images
and other media, as well as executable content. Specifically, the Object Module supports:
When this module is used, it adds the object element to the Text [p.51] content set of the Text
[p.51] module.
declare = "declare"
When present, this boolean attribute makes the current element a declaration only - one
that is to be executed only after the document has completed loading and has been called
- 121 -
25.1.1. Defining terminology XHTML™ 2.0
In the most general case, an author should specify three types of information:
The location of the object data (the src attribute). The author must direct the object handler
to the actual physical location of the object data, otherwise the object handler will not be
able to process the request.
The media type associated with the object data (the type attribute). For instance, if the
author prefers that a particular object handler be used to process the data, they may specify
a media type that is associated to a specific object handler.
Additional values required for the appropriate processing of the object data by the object
handler at run-time (via the param element). Some instances may process more
appropriately if the object handler is passed initial process instructions. For example, the
author can specify whether a video should automatically start or wait until the entire data file
has been downloaded.
The object [p.121] element allows authors to specify all three types of information, but authors
may not have to specify all three at once. For example, some object element instances may not
require src (e.g., a self-contained applet that performs a small animation). Others may not
require media type information, i.e., the user agent itself may already know how to process that
type of data. Still others may not require run-time initialization.
- 122 -
XHTML™ 2.0 25.1.3. Rules for processing objects
The object [p.121] element may also appear in the content of the head [p.38] element. Since
user agents generally do not render elements in the head [p.38] , authors should ensure that any
object [p.121] element in the head [p.38] does not specify content that is expected to be made
available to the user.
1. The user agent MUST first try to process the object element. It should not process the
embedded contents, but it must examine them for definitions of param [p.126] elements
(see object initialization) or elements that take advantage of the Map [p.96] attribute
collection.
2. If the user agent is not able to process the object for whatever reason (configured not to,
lack of resources, wrong architecture, etc.), it MUST try to process its contents.
When a user agent is able to successfully process an object element it MUST not attempt to
process inner elements.
If a user agent cannot process an object element or a set of nested objects, and the author did
not provide alternate text, the user agent SHOULD NOT supply any additional information. It is
the responsibility of the author to supply additional or alternate information. It may be the intent
of the author to not provide additional information if the object cannot be processed.
The user agent SHOULD attempt to process the outer object to its fullest extent before
cascading to a nested object. For example, if the author provided information that could be used
to download an external application to be used to process the object, then the user agent
SHOULD attempt to download and install the application. If the user selects to not install the
application, the user agent SHOULD continue to process the nested object or objects, if they
exist.
The following example shows a minimally coded object [p.121] element. The src [p.88] attribute
specifies the location of the object data:
Example
<object src="http://www.example.com/foo.mp3">
<em>alternate text</em>
</object>
The following example shows an object [p.121] element coded to process an image. The src
[p.88] attribute specifies the location of the object data, in this case the image to be processed,
and the srctype [p.88] attribute specifies the media type associated with the object data:
Example
- 123 -
25.1.3. Rules for processing objects XHTML™ 2.0
The following example shows how an applet element can be converted to an object [p.121]
element. The codebase attribute is replaced with the xml:base attribute. The code attribute is
replaced with the src [p.88] attribute. The width and the height of the applet are defined using
CSS. The param [p.126] elements are not modified since the values within the param [p.126]
elements are passed directly to the external application. If a particular version reference is
required, that would be appended to the content of the type attribute. For example,
type="application/x-java-applet;version=1.4.1"
If the archive attribute is used, the object handler should process the search order by
interpreting the archive attribute value first and then the xml:base attribute value.
Example
<applet
codebase="http://www.example.com/applets/classes"
code="Clock.class"
width="150"
height="150">
<param name="bgcolor" value="ffffff"/>
<param name="border" value="5"/>
<param name="ccolor" value="dddddd"/>
<param name="cfont" value="TimesRoman|BOLD|18"/>
<param name="delay" value="100"/>
<param name="hhcolor" value="0000ff"/>
<param name="link" value="http://www.example.com/"/>
<param name="mhcolor" value="00ff00"/>
<param name="ncolor" value="000000"/>
<param name="nradius" value="80"/>
<param name="shcolor" value="ff0000"/>
</applet>
Example
<style type="text/css">
#obj1 {width:150px; height:150px;}
</style>
...
<object id="obj1"
xml:base="http://www.example.com/applets/classes"
srctype="application/x-java-applet"
src="Clock.class">
<param name="delay" value="100"/>
<param name="link" value="http://www.example.com/"/>
<param name="border" value="5"/>
<param name="nradius" value="80"/>
<param name="cfont" value="TimesRoman|BOLD|18"/>
<param name="bgcolor" value="ddddff"/>
<param name="shcolor" value="ff0000"/>
<param name="mhcolor" value="00ff00"/>
- 124 -
XHTML™ 2.0 25.1.3. Rules for processing objects
</object>
Authors should always include alternate text as the content of the object [p.121] element
declaration when an embedded object is not defined.
The following example demonstrates how alternate text may be used within an object [p.121]
element.
Example
<object src="http://www.example.com/foo.mp3" srctype="audio/mpeg">
A really cool audio file. If you want to download and install
a plug-in to listen to this file, please go to
<a href="http://www.example.com">www.example.com</a>
</object>
In the following example, we embed several object [p.121] element declarations to illustrate how
alternate processing works. In the following order: (1) an Earth applet, (2) an animation of the
Earth, (3) an image of the Earth, (4) alternate text.
Example
<!-- First, try the applet -->
<object
src="http://www.example.com/applets/classes/TheEarth.class"
srctype="application/x-java-applet">
The outermost object [p.121] element declaration specifies an applet that requires no initial
values, the src [p.88] attribute points to the applet class file, and the srctype [p.88] attribute
defines the media type. An xml:base [p.74] attribute could have been used to point to the base
location to access the class file. In this example, however, the src [p.88] attribute value contains
- 125 -
25.2. The param element XHTML™ 2.0
an absolute URL so the xml:base [p.74] attribute was not required. An archive [p.121] attribute
could have been used if the author needed to include any associated files. The second object
[p.121] element declaration specifies an MPEG animation, and the xml:base [p.74] attribute
defines the location of the object data defined in the src [p.88] attribute. We also set the srctype
[p.88] attribute so that a user agent can determine if it has the capability to process the object
data or to invoke an external application to process the MPEG. The third object element
declaration specifies a PNG file and furnishes alternate text in case all other mechanisms fail.
Inline vs. external data. Data to be processed may be supplied in two ways: inline and from an
external resource. While the former method will generally lead to faster processing, it is not
convenient when processing large quantities of data.
valuetype = data|ref|object
This attribute specifies the type of the value attribute.
Possible values:
data: This is the default value for the attribute. It means that the value specified by
value [p.126] will be evaluated and passed to the object’s implementation as a string.
ref: The value specified by value [p.126] is a URI that designates a resource where
run-time values are stored. This allows support tools to identify URIs given as
parameters. The URI must be passed to the object as is, i.e., unresolved.
object: The value specified by value [p.126] is an identifier that refers to an object
[p.121] declaration in the same document. The identifier must be the value of the id
[p.67] attribute set for the declared object [p.121] element.
- 126 -
XHTML™ 2.0 25.2. The param element
param [p.126] elements specify a set of values that may be required to process the object data
by an object handler at run-time. Any number of param [p.126] elements may appear in the
content of an object [p.121] element, in any order, but must be placed at the start of the content
of the enclosing object [p.121] element, with the exception of optional caption [p.142] and
standby [p.130] elements.
The syntax of names and values is assumed to be understood by the user agent or the external
application that will process the object data. This document does not specify how object
handlers should retrieve name/value pairs nor how they should interpret parameter names that
appear twice.
The user agent or the external application can utilize the param [p.126] element name/value
pairs to pass unique datapoints to trigger specific functions or actions. For example, the user
agent may wish to trigger an external application download if the user does not have an
appropriate application installed on their system.
We return to the clock example to illustrate the use of the param [p.126] element. For example,
suppose that the applet is able to handle two run-time parameters that define its initial height
and width. We can set the initial dimensions to 40x40 pixels with two param [p.126] elements.
Example
<object
src="http://www.example.com/myclock.class"
srctype="application/x-java-applet">
<param name="height" value="40" valuetype="data" />
<param name="width" value="40" valuetype="data" />
This user agent cannot process a java applet.
</object>
In the following example, run-time data for the object’s "Init_values" parameter is specified as an
external resource (a GIF file). The value of the valuetype [p.126] attribute is thus set to "ref" and
the value [p.126] is a URI designating the resource.
Example
<object
src="http://www.example.com/gifappli"
srctype="image/gif">
<standby>Loading Elvis...</standby>
<param name="Init_values"
value="./images/elvis.gif"
valuetype="ref" />
Elvis lives!
</object>
Note that we have also set the standby [p.130] element so that the object handler may display a
message while the object data is downloading.
- 127 -
25.2.1. Referencing object data XHTML™ 2.0
When an object [p.121] element is processed, the user agent must search the content for only
those param [p.126] elements that are direct children and "feed" them to the object handler.
Thus, in the following example, if "obj1" is processed, then the name/value content of "param1"
applies to "obj1" (and not "obj2"). If "obj1" is not processed and "obj2" is, "param1" is ignored,
and the name/value content of "param2" applies to "obj2". If neither object [p.121] element is
processed, neither param [p.126] name/value content applies.
Example
<object
src="obj1"
srctype="application/x-something">
<param name="param1" value="value1" />
<object
src="obj2"
srctype="application/x-something">
<param name="param2" value="value2" />
This user agent cannot process this application.
</object>
</object>
Example
<object
src="mymovie.mpg"
srctype="video/mpeg">
A film showing how to open the printer to replace the cartridge.
</object>
By setting the srctype [p.88] attribute, a user agent can determine whether to retrieve the
external application based on its ability to do so. The location of the object data is relative to the
referencing document, in this example the object data would need to exist within the same
directory.
The following example specifies a base location via the xml:base [p.74] attribute. The src [p.88]
attribute defines the data to process.
Example
- 128 -
XHTML™ 2.0 25.2.2. Object element declarations and instantiations
<object
xml:base="http://www.example.com/"
src="mymovie.mpg"
srctype="video/mpeg">
This user agent cannot process this movie.
</object>
The object data may be retrieved from the network by the object handler one time (during
the declaration) and reused for each additional reference to that object data.
It is possible to reference the object data from a location other than the object element in
which it was defined, for example, from a link.
It is possible to specify an object data as run-time data for other object element
declarations.
To declare an object element so that it is not executed when read by the object handler, set the
boolean declare [p.121] attribute in the object [p.121] element. At the same time, authors must
identify the object declaration by setting the id [p.67] attribute in the object [p.121] element to a
unique value. Later processing of the object data will refer to this identifier.
A declared object [p.121] element must appear in a document before the first time the object
data is referenced. For example, the declaring object element must appear before a link
referencing the object data.
When an object element is defined with the declare [p.121] attribute, the object handler is
instantiated every time an element refers to that object data later in the document. The
references will require the object data to be processed (e.g., a link that refers to it is activated,
an object element that refers to it is activated, etc.).
In the following example, we declare an object [p.121] element and cause the object handler to
be instantiated by referring to it from a link. Thus, the object data can be activated by clicking on
some highlighted text, for example.
Example
<object
declare="declare"
id="earth.declaration"
src="TheEarth.mpg"
srctype="video/mpeg">
The <strong>Earth</strong> as seen from space.
</object>
<em>...later in the document...</em>
<p>A neat <a href="#earth.declaration">animation of The Earth!</a></p>
- 129 -
25.3. The standby element XHTML™ 2.0
In the previous example, when the document is initially loaded the object data should not be
processed. If this was to be processed within a visual user agent, the object data would not be
displayed. When the user selects the anchor data, the object data would then be initialized and
displayed. This would also be the case for an audio file, where the file would be instantiated but
would not be processed. Selecting the anchor data would then trigger the audio file to be
processed.
User agents that do not support the declare [p.121] attribute must process the contents of the
object [p.121] element.
The standby [p.130] element specifies a message that a user agent may render while loading
the object’s implementation and data.
- 130 -
XHTML™ 2.0 26. XHTML Role Attribute Module
This module defines the role attribute and the associated Role Attribute Collection.
Example
<nl role="wai:sitemap">
<li href="downloads">Downloads</li>
<li href="docs">Documentation</li>
<li href="news">News</li>
</nl>
It is possible to define additional role values. Such values MUST be defined in their own
namespace. Note that current best practice is that the URI associated with that namespace
resolve to a resource that allows for the discovery of the definition of the roles in the
namespace. Example definitions include the RDF Schema for the XHTML role attribute
values in Appendix I [p.239] , and the Web Accessibility Initiative’s work on an RDF
Taxonomy [WAIRDF [p.249] ].
Authors may use the following relationship names, listed here with their conventional
interpretations. User agents, search engines, etc. may interpret these relationships in a
variety of ways. For example, user agents may provide access to linked documents through
a navigation bar.
The following attribute values are designed to define pertinent parts of a document for the
purpose of accessibility. User agents may incorporate device equivalents, such as key
mappings in the case of a desktop user agent, to navigate to these sections of a document.
main
This defines the main content of a document.
secondary
This is any unique section of the document. In the case of a portal, this may include but
not be limited to: show times; current weather; or stocks to watch.
- 131 -
26.1. Role Attribute Collection XHTML™ 2.0
navigation
This is the navigation bar on a web document. This is typically a list of links to other
pages on the site or other areas of the same document.
banner
A banner is usually defined as the advertisement at the top of a web page. The banner
content typically contains the site or company logo and other key advertisements for
the site.
contentinfo
This is information about the content on the page. For example, footnotes, copyrights,
links to privacy statements, etc. would belong here.
definition
The contents of the associated element represent a definition (e.g., of a term or
concept). If there is a dfn [p.53] element within the contents, then that represents the
term being defined.
note
The content is parenthetic or ancillary to the main content of the resource.
seealso
Indicates that the element contains content that is related to the main content of the
page.
search
This is the search section of a web document. This is typically a form used to submit
search requests about the site or is a more general Internet wide search service.
- 132 -
XHTML™ 2.0 27. Ruby Module
The Ruby Module defines elements for ruby annotation markup as defined in Ruby Annotation
[RUBY [p.248] ].
This module adds the ruby element to the Text [p.51] content set of the Text [p.51] Module.
XHTML 2.0 supports the maximal content model for the ruby element, defined as follows:
((rb, (rt | (rp, rt, rp))) | (rbc, rtc, rtc?))
- 133 -
27. Ruby Module XHTML™ 2.0
- 134 -
XHTML™ 2.0 28. XHTML Style Attribute Module
Note: use of the style [p.135] attribute is strongly discouraged in favor of the style [p.137]
element and external style sheets. In addition, content developers are advised to avoid use of
the style [p.135] attribute on content intended for use on small devices, since those devices may
not support the use of in-line styles.
The syntax of the value of the style [p.135] attribute is determined by the default style sheet
language.
This CSS example sets color and font size information for the text in a specific paragraph.
Example
<p style="font-size: 12pt; color: fuchsia">
Aren’t style sheets wonderful?</p>
In CSS, property declarations have the form "name : value" and are separated by a
semi-colon.
To specify style information for more than one element, authors should use the style [p.137]
element. For optimal flexibility, authors should define styles in external style sheets.
28.2. Issues
RE: [BULK] - Re: [XHTML2] Spirit of "1.1.3. XHTML 2 and Presentation" PR #7870
State: Open
Resolution: None
User: None
Notes:
Re: [BULK] - Re: [XHTML2] Spirit of "1.1.3. XHTML 2 and Presentation" PR #7871
State: Open
Resolution: None
User: None
- 135 -
28.2. Issues XHTML™ 2.0
Notes:
- 136 -
XHTML™ 2.0 29. XHTML Style Sheet Module
The Style Sheet Module defines an element to be used when declaring internal style sheets.
The element and attributes defined by this module are:
Content
Elements Attributes
Model
style Common [p.34] , disabled [p.137] ("disabled"), media [p.137]
PCDATA
[p.137] (MediaDesc [p.31] )
disabled = "disabled"
When present, this boolean attribute makes the current element inactive (e.g., a "disabled"
style element would have its styles removed from the active style collection).
The style [p.137] element allows an author to put style sheet rules in the head of the document.
XHTML permits any number of style [p.137] elements in the head [p.38] section of a document.
Rules for style rule precedences and inheritance depend on the style sheet language.
Example
- 137 -
29.1.1. External style sheets XHTML™ 2.0
<style type="text/css">
h1 {border-width: thin; border-style: solid; text-align: center}
</style>
Authors and web site managers may share style sheets across a number of documents
(and sites).
Authors may change the style sheet without requiring modifications to the document.
User agents may load style sheets selectively (based on media descriptors).
Authors may specify a number of mutually exclusive style sheets called alternate style sheets.
Users may select their favorite among these depending on their preferences. For instance, an
author may specify one style sheet designed for small screens and another for users with weak
vision (e.g., large fonts). User agents should allow users to select from alternate style sheets.
The author may specify that one of the alternates is a preferred style sheet. User agents should
apply the author’s preferred style sheet unless the user has selected a different alternate.
Authors may group several alternate style sheets (including the author’s preferred style sheets)
under a single style name. When a user selects a named style, the user agent must apply all
style sheets with that name. User agents must not apply alternate style sheets with a different
style name. The section on specifying external style sheets explains how to name a group of
style sheets.
Authors may also specify persistent style sheets that user agents must apply in addition to any
alternate style sheet.
User agents must respect media descriptors [p.31] when applying any style sheet.
User agents should also allow users to disable the author’s style sheets entirely, in which case
the user agent must not apply any persistent or alternate style sheets.
- 138 -
XHTML™ 2.0 29.1.3. Specifying external style sheets
User agents should provide a means for users to view and pick from the list of alternate styles, if
specified.
In this example, we first specify a persistent style sheet located in the file mystyle.css:
Example
<?xml-stylesheet href="mystyle.css" type="text/css"?>
Setting the title pseudo-attribute makes this the author’s preferred style sheet:
Example
<?xml-stylesheet href="mystyle.css" title="compact" type="text/css"?>
Example
<?xml-stylesheet href="mystyle.css" title="Medium" alternate="yes" type="text/css"?>
- 139 -
29.1.3. Specifying external style sheets XHTML™ 2.0
- 140 -
XHTML™ 2.0 30. XHTML Tables Module
The Tables Module provides elements for marking up tabular information in a document.
The module supports the following elements, attributes, and content model:
When this module is used, it adds the table [p.145] element to the Structural [p.43] content set of
the Structural Module.
- 141 -
30.1. The caption element XHTML™ 2.0
When present, the caption [p.142] element’s text should describe the nature of the table or the
object. The caption [p.142] element is only permitted immediately after the table [p.145] start tag
or the object [p.121] start tag. A table [p.145] element or an object [p.121] element may only
contain one caption [p.142] element.
For tables, visual user agents allow sighted people to quickly grasp the structure of the table
from the headings as well as the caption. A consequence of this is that captions will often be
inadequate as a summary of the purpose and structure of the table from the perspective of
people relying on non-visual user agents.
In the absence of a span [p.142] attribute, each colgroup [p.142] defines a column
group containing one column.
If the span [p.142] attribute is used with the colgroup [p.142] element and the value is
set to N > 0, that defines a column group containing N columns.
If the span [p.142] attribute is used with the col [p.142] element and the value is set to
N > 1, the current col [p.142] element shares its attributes with the next N-1 columns.
User agents must ignore this attribute if the colgroup [p.142] element contains one or more
col [p.142] elements. Instead, the value must be computed by summing the span attributes
of the enclosed col [p.142] elements.
- 142 -
XHTML™ 2.0 30.2. The col and colgroup elements
The colgroup [p.142] element allows authors to create structural divisions within a table. Authors
may highlight this structure through style sheets. For example, the author may wish to divide the
columns into logical groups such as the student’s permanent address, phone number and
emergency contact information. And group the student’s local address, phone and email
address into another logical group.
A table [p.145] may either contain a single implicit column group (no colgroup [p.142] element
delimits the columns) or any number of explicit column groups (each delimited by an instance of
the colgroup [p.142] element).
The col [p.142] element allows authors to share attributes among several columns without
implying any structural grouping. The "span" of the col [p.142] element is the number of columns
that will share the element’s attributes. For example, the author may wish to apply a specific
style to the student’s permanent data and apply a different style to the student’s local data.
The colgroup [p.142] element creates an explicit column group. The number of columns in the
column group may be specified in two, mutually exclusive ways:
1. The colgroup span [p.142] attribute (default value 1) specifies the number of columns in the
group.
2. Each embedded col [p.142] element in the colgroup [p.142] represents one or more
columns in the group.
The advantage of using the colgroup [p.142] element is that authors may logically group multiple
columns. By grouping columns, the author can apply rules across the entire group. The author
can also apply column width balancing across the group of columns. For example, if the author
has a table with five columns and the author divides the table into two column groups, one with
three columns and the other with two columns. The author could define the first column group to
consume 300 pixels and the second column group to consume 100 pixels. Each column within
the first column group would be 100 pixels wide and the remaining two columns would be 50
pixels wide. If the author added embedded col [p.142] elements, she could force one or more
columns to be a specific width and the remaining columns within the group would be evenly
divided within the remaining allotted width.
For example, the following table defines a column group and embedded columns with differing
widths.
Example
<style type="text/css">
#colgrp1 { width: 300px }
#col1 { width: 100px }
#col2 { width: 50px }
</style>
...
<table>
<colgroup id="colgrp1">
<col id="col1" span="3"/>
- 143 -
30.2.1. Calculating the number of columns in a table XHTML™ 2.0
In this example, the defined width for the colgroup [p.142] constrains all of the columns to fit
within that value regardless of the of the defined values within the col [p.142] elements. In this
example, the width of the columns within the column group must be constrained to fit the defined
width of the column group.
When it is necessary to single out a column (e.g., for style information, to specify width
information, etc.) within a group, authors must identify that column with a col [p.142] element.
The col [p.142] element allows authors to group together attribute specifications for table
columns. The col [p.142] does not group columns together structurally -- that is the role of the
colgroup [p.142] element. col [p.142] elements are empty and serve only as a support for
attributes. They may appear inside or outside an explicit column group (i.e., colgroup [p.142]
element).
1. If the table [p.145] element contains any colgroup [p.142] or col [p.142] elements, user
agents should calculate the number of columns by summing the following:
For each col [p.142] element, take the value of its span [p.142] attribute (default value
1).
For each colgroup [p.142] element containing at least one col [p.142] element, ignore
the span [p.142] attribute for the colgroup [p.142] element. For each col [p.142]
element, perform the calculation of step 1.
For each empty colgroup [p.142] element, take the value of its span [p.142] attribute
(default value 1).
2. Otherwise, if the table [p.145] element contains no colgroup [p.142] or col [p.142] elements,
user agents should base the number of columns on what is required by the rows. The
number of columns is equal to the number of columns required by the row with the most
columns, including cells that span multiple columns. For any row that has fewer than this
number of columns, the end of that row should be padded with empty cells. The "end" of a
row depends on the directionality of a table.
It is an error if a table contains colgroup [p.142] or col [p.142] elements and the two calculations
do not result in the same number of columns.
Once the user agent has calculated the number of columns in the table, it may group them into a
colgroup [p.142] .
- 144 -
XHTML™ 2.0 30.3. The summary element
This element provides a summary of the table’s purpose and structure for user agents rendering
to non-visual media such as speech and Braille.
User agents MUST provide access to the content of the summary [p.145] element. As an
example, access could be provided through a menu option, a mouse-over function, or through a
dialog.
The following example demonstrates the difference between a table caption and a table
summary.
Example
<table>
<caption>Student Class Roster</caption>
<summary>The table defines the class roster.
The columns contain the following data:
students name, permanent address, permanent phone,
local address, local phone,
declared major, assigned academic advisor,
student standing</summary>
<em>...the rest of the table...</em>
</table>
The table [p.145] element contains all other elements that specify the caption, column groups,
columns, rows, and content for a table.
- 145 -
30.4.1. Visual Rendering XHTML™ 2.0
Although CSS2 is not required, the equivalent effect MUST BE followed and integrated into the
rendering model.
The following informative list describes what operations visual user agents may carry out when
rendering a table:
Provide access to the content of the summary [p.145] element. As an example, access
could be provided through a menu option, a mouse-over function, or through a dialog.
Authors should provide a summary of a table’s content and structure so that people using
non-visual user agents may better understand it.
Render the caption, if one is defined. The caption may be rendered, for example, either on
the top or the bottom of the table.
Render the table header, if one is specified. Render the table footer, if one is specified. User
agents must know where to render the header and footer. For instance, if the output
medium is paged, user agents may put the header at the top of each page and the footer at
the bottom. Similarly, if the user agent provides a mechanism to scroll the rows, the header
may appear at the top of the scrolled area and the footer at the bottom.
Calculate the number of columns [p.144] in the table. Note that the number of rows in a
table is equal to the number of tr [p.161] elements contained by the table [p.145] element.
Group the columns according to any column groups [p.142] specifications.
Render the cells, row by row and grouped in appropriate columns, between the header and
footer. Visual user agents should format the table according to XHTML attributes and style
sheet specification.
For a left-to-right table, column zero is on the left side and row zero is at the top. For a
right-to-left table, column zero is on the right side and row zero is at the top.
When a user agent allots extra cells to a row, extra row cells are added to the right of the table
for left-to-right tables and to the left side for right-to-left tables.
Note that table [p.145] is the only element on which dir [p.81] reverses the visual order of the
columns; a single table row ( tr [p.161] ) or a group of columns ( colgroup [p.142] ) cannot be
independently reversed.
When set for or inherited by the table [p.145] element, the dir [p.81] attribute also affects the
direction of text within table cells (since the dir [p.81] attribute is inherited by block-level
elements).
- 146 -
XHTML™ 2.0 30.4.3. Table rendering by non-visual user agents
Example
<table dir="rtl">
<em>...the rest of the table...</em>
</table>
The direction of text in individual cells can be changed by setting the dir [p.81] attribute in an
element that defines the cell.
For a given data cell, the headers [p.155] attribute lists which cells provide pertinent header
information. For this purpose, each header cell must be named using the id [p.67] attribute.
Note that it’s not always possible to make a clean division of cells into headers or data. You
should use the td [p.155] element for such cells together with the id [p.67] or scope [p.156]
attributes as appropriate.
For a given header cell, the scope [p.156] attribute tells the user agent the data cells for
which this header provides information. Authors may choose to use this attribute instead of
headers [p.155] according to which is more convenient; the two attributes fulfill the same
function. The headers [p.155] attribute is generally needed when headers are placed in
irregular positions with respect to the data they apply to.
The abbr [p.155] attribute specifies an abbreviated header for header cells so that user
agents may render header information more rapidly.
In the following example, we assign header information to cells by setting the headers [p.155]
attribute. Each cell in the same column refers to the same header cell (via the id [p.67] attribute).
Example
<table>
<caption>Cups of coffee consumed by each senator</caption>
<summary>This table charts the number of cups
of coffee consumed by each senator, the type
of coffee (decaf or regular), and whether
taken with sugar.</summary>
<tbody>
<tr>
<th id="t1">Name</th>
<th id="t2">Cups</th>
<th id="t3" abbr="Type">Type of Coffee</th>
- 147 -
30.4.3. Table rendering by non-visual user agents XHTML™ 2.0
<th id="t4">Sugar?</th>
</tr>
<tr>
<td headers="t1">T. Sexton</td>
<td headers="t2">10</td>
<td headers="t3">Espresso</td>
<td headers="t4">No</td>
</tr>
<tr>
<td headers="t1">J. Dinnen</td>
<td headers="t2">5</td>
<td headers="t3">Decaf</td>
<td headers="t4">Yes</td>
</tr>
</tbody>
</table>
Example
Caption: Cups of coffee consumed by each senator
Summary: This table charts the number of cups
of coffee consumed by each senator, the type
of coffee (decaf or regular), and whether
taken with sugar.
Name: T. Sexton, Cups: 10, Type: Espresso, Sugar: No
Name: J. Dinnen, Cups: 5, Type: Decaf, Sugar: Yes
Note how the header "Type of Coffee" is abbreviated to "Type" using the abbr [p.155] attribute.
Here is the same example substituting the scope [p.156] attribute for the headers [p.155]
attribute. Note the value "col" for the scope [p.156] attribute, meaning "all cells in the current
column":
Example
<table>
<caption>Cups of coffee consumed by each senator</caption>
<summary>
This table charts the number of cups
of coffee consumed by each senator, the type
of coffee (decaf or regular), and whether
taken with sugar.
</summary>
<tbody>
<tr>
<th scope="col">Name</th>
<th scope="col">Cups</th>
<th scope="col" abbr="Type">Type of Coffee</th>
<th scope="col">Sugar?</th>
</tr>
<tr>
<td>T. Sexton</td>
<td>10</td>
- 148 -
XHTML™ 2.0 30.4.3. Table rendering by non-visual user agents
<td>Espresso</td>
<td>No</td>
</tr>
<tr>
<td>J. Dinnen</td>
<td>5</td>
<td>Decaf</td>
<td>Yes</td>
</tr>
</tbody>
</table>
Here’s a somewhat more complex example illustrating other values for the scope [p.156]
attribute:
Example
<table>
<summary>
History courses offered in the community of
Bath arranged by course name, tutor, summary,
code, and fee
</summary>
<thead>
<tr>
<th colspan="5" scope="colgroup">Community Courses -- Bath Autumn 1997</th>
</tr>
</thead>
<tbody>
<tr>
<th scope="col" abbr="Name">Course Name</th>
<th scope="col" abbr="Tutor">Course Tutor</th>
<th scope="col">Summary</th>
<th scope="col">Code</th>
<th scope="col">Fee</th>
</tr>
<tr>
<td scope="row">After the Civil War</td>
<td>Dr. John Wroughton</td>
<td>
The course will examine the turbulent years in England
after 1646. <em>6 weekly meetings starting Monday 13th
October.</em>
</td>
<td>H27</td>
<td>&pound;32</td>
</tr>
<tr>
<td scope="row">An Introduction to Anglo-Saxon England</td>
<td>Mark Cottle</td>
<td>
One day course introducing the early medieval
period reconstruction the Anglo-Saxons and
their society. <em>Saturday 18th October.</em>
</td>
<td>H28</td>
- 149 -
30.4.3. Table rendering by non-visual user agents XHTML™ 2.0
<td>&pound;18</td>
</tr>
<tr>
<td scope="row">The Glory that was Greece</td>
<td>Valerie Lorenz</td>
<td>
Birthplace of democracy, philosophy, heartland of theater, home of
argument. The Romans may have done it but the Greeks did it
first. <em>Saturday day school 25th October 1997</em>
</td>
<td>H30</td>
<td>&pound;18</td>
</tr>
</tbody>
</table>
Note the use of the scope [p.156] attribute with the "row" value. Although the first cell in each
row contains data, not header information, the scope [p.156] attribute makes the data cell
behave like a row header cell. This allows speech synthesizers to provide the relevant course
name upon request or to state it immediately before each cell’s content.
- 150 -
XHTML™ 2.0 30.4.3. Table rendering by non-visual user agents
Users may also want information about more than one cell, in which case header information
provided at the cell level (by headers [p.155] , scope [p.156] , and abbr [p.155] ) may not provide
adequate context. Consider the following table, which classifies expenses for meals, hotels, and
transport in two locations (San Jose and Seattle) over several days:
Users might want to extract information from the table in the form of queries:
Each query involves a computation by the user agent that may involve zero or more cells. In
order to determine, for example, the costs of meals on 25 August, the user agent must know
which table cells refer to "Meals" (all of them) and which refer to "Dates" (specifically, 25
August), and find the intersection of the two sets.
To accommodate this type of query, the table model allows authors to place cell headers and
data into categories. For example, for the travel expense table, an author could group the
header cells "San Jose" and "Seattle" into the category "Location", the headers "Meals",
"Hotels", and "Transport" in the category "Expenses", and the four days into the category "Date".
The previous three questions would then have the following meanings:
"What did I spend for all my meals?" means "What are all the data cells in the
"Expenses=Meals" category?
"What did I spend for meals on 25 August?" means "What are all the data cells in the
"Expenses=Meals" and "Date=Aug-25-1997" categories?
"What did I spend for all expenses in San Jose?" means "What are all the data cells in the
"Expenses=Meals, Hotels, Transport" and "Location=San Jose" categories?
Authors categorize a header or data cell by setting the axis [p.155] attribute for the cell. For
instance, in the travel expense table, the cell containing the information "San Jose" could be
placed in the "Location" category as follows:
- 151 -
30.4.3. Table rendering by non-visual user agents XHTML™ 2.0
Example
<th id="a6" axis="location">San Jose</th>
Any cell containing information related to "San Jose" should refer to this header cell via either
the headers [p.155] or the scope [p.156] attribute. Thus, meal expenses for 25-Aug-1997 should
be marked up to refer to id [p.67] attribute (whose value here is "a6") of the "San Jose" header
cell:
Example
<td headers="a6">37.74</td>
Each headers [p.155] attribute provides a list of id [p.67] references. Authors may thus
categorize a given cell in any number of ways (or, along any number of "headers", hence the
name).
Example
<table>
<caption>Travel Expense Report</caption>
<summary>
This table summarizes travel expenses
incurred during August trips to
San Jose and Seattle
</summary>
<tbody>
<tr>
<th></th>
<th id="a2" axis="expenses">Meals</th>
<th id="a3" axis="expenses">Hotels</th>
<th id="a4" axis="expenses">Transport</th>
<td>subtotals</td>
</tr>
<tr>
<th id="a6" axis="location">San Jose</th>
<th></th>
<th></th>
<th></th>
<td></td>
</tr>
<tr>
<td id="a7" axis="date">25-Aug-97</td>
<td headers="a6 a7 a2">37.74</td>
<td headers="a6 a7 a3">112.00</td>
<td headers="a6 a7 a4">45.00</td>
<td></td>
</tr>
<tr>
<td id="a8" axis="date">26-Aug-97</td>
<td headers="a6 a8 a2">27.28</td>
<td headers="a6 a8 a3">112.00</td>
- 152 -
XHTML™ 2.0 30.4.3. Table rendering by non-visual user agents
Note that marking up the table this way also allows user agents to avoid confusing the user with
unwanted information. For instance, if a speech synthesizer were to speak all of the figures in
the "Meals" column of this table in response to the query "What were all my meal expenses?", a
user would not be able to distinguish a day’s expenses from subtotals or totals. By carefully
categorizing cell data, authors allow user agents to make important semantic distinctions when
rendering.
- 153 -
30.4.3. Table rendering by non-visual user agents XHTML™ 2.0
Of course, there is no limit to how authors may categorize information in a table. In the travel
expense table, for example, we could add the additional categories "subtotals" and "totals".
This specification does not require user agents to handle information provided by the axis
[p.155] attribute, nor does it make any recommendations about how user agents may present
axis [p.155] information to users or how users may query the user agent about this information.
However, user agents, particularly speech synthesizers, may want to factor out information
common to several cells that are the result of a query. For instance, if the user asks "What did I
spend for meals in San Jose?", the user agent would first determine the cells in question
(25-Aug-1997: 37.74, 26-Aug-1997:27.28), then render this information. A user agent speaking
this information might read it:
Example
Location: San Jose. Date: 25-Aug-1997. Expenses, Meals: 37.74
Location: San Jose. Date: 26-Aug-1997. Expenses, Meals: 27.28
Example
San Jose, 25-Aug-1997, Meals: 37.74
San Jose, 26-Aug-1997, Meals: 27.28
An even more economical rendering would factor the common information and reorder it:
Example
San Jose, Meals, 25-Aug-1997: 37.74
26-Aug-1997: 27.28
User agents that support this type of rendering should allow authors a means to customize
rendering (e.g., through style sheets).
First, search left from the cell’s position to find row header cells. Then search upwards to
find column header cells. The search in a given direction stops when the edge of the table is
reached or when a data cell is found after a header cell.
Row headers are inserted into the list in the order they appear in the table. For left-to-right
tables, headers are inserted from left to right.
Column headers are inserted after row headers, in the order they appear in the table, from
top to bottom.
- 154 -
XHTML™ 2.0 30.5. The tbody element
If a header cell has the headers [p.155] attribute set, then the headers referenced by this
attribute are inserted into the list and the search stops for the current direction.
td [p.155] cells that set the axis [p.155] attribute are also treated as header cells.
The tbody [p.155] element contains rows of table data. In tables that also contain thead [p.160]
or tfoot [p.160] elements, all of these sections must contain the same number of columns.
- 155 -
30.6. The td and th elements XHTML™ 2.0
scope = row|col|rowgroup|colgroup
This attribute specifies the set of data cells for which the current header cell provides
header information. This attribute may be used in place of the headers [p.156] attribute,
particularly for simple tables. When specified, this attribute must have one of the following
values:
row: The current cell provides header information for the rest of the row that contains it
(see also the section on table directionality [p.146] ).
col: The current cell provides header information for the rest of the column that
contains it.
rowgroup: The header cell provides header information for the rest of the row group
that contains it.
colgroup: The header cell provides header information for the rest of the column group
[p.142] that contains it.
Table cells may contain two types of information: header information and data. This distinction
enables user agents to render header and data cells distinctly, even in the absence of style
sheets. For example, visual user agents may present header cell text with a bold font. Speech
synthesizers may render header information with a distinct voice inflection.
The th [p.155] element defines a cell that contains header information. User agents have two
pieces of header information available: the contents of the th [p.155] element and the value of
the abbr [p.155] attribute. User agents must render either the contents of the cell or the value of
the abbr [p.155] attribute. For visual media, the latter may be appropriate when there is
insufficient space to render the full contents of the cell. For non-visual media abbr [p.155] may
be used as an abbreviation for table headers when these are rendered along with the contents
of the cells to which they apply.
The headers [p.156] and scope [p.156] attributes also allow authors to help non-visual user
agents process header information. Please consult the section on labeling cells for non-visual
user agents [p.147] for information and examples.
- 156 -
XHTML™ 2.0 30.6.1. Cells that span several rows or columns
In this table definition, we specify that the cell in row four, column two should span a total of
three columns, including the current column.
<table>
<caption>Cups of coffee consumed by each senator</caption>
<tbody>
<tr>
<th>Name</th>
<th>Cups</th>
<th>Type of Coffee</th>
<th>Sugar?</th>
</tr>
<tr>
<td>T. Sexton</td>
<td>10</td>
<td>Espresso</td>
<td>No</td>
</tr>
<tr>
<td>J. Dinnen</td>
<td>5</td>
<td>Decaf</td>
<td>Yes</td>
</tr>
<tr>
<td>A. Soria</td>
<td colspan="3"><em>Not available</em></td>
</tr>
</tbody>
</table>
This table might be rendered on a tty device by a visual user agent as follows:
Cups of coffee consumed by each senator
--------------------------------------
| Name |Cups|Type of Coffee|Sugar?|
--------------------------------------
|T. Sexton|10 |Espresso |No |
--------------------------------------
|J. Dinnen|5 |Decaf |Yes |
--------------------------------------
|A. Soria |Not available |
--------------------------------------
- 157 -
30.6.1. Cells that span several rows or columns XHTML™ 2.0
The next example illustrates (with the help of table borders) how cell definitions that span more
than one row or column affect the definition of later cells. Consider the following table definition:
<table>
<tbody>
<tr>
<td>1</td>
<td rowspan="2">2</td>
<td>3</td>
</tr>
<tr>
<td>4</td>
<td>6</td>
</tr>
<tr>
<td>7</td>
<td>8</td>
<td>9</td>
<td></td>
</tr>
</tbody>
</table>
As cell "2" spans the first and second rows, the definition of the second row will take it into
account. Thus, the second td [p.155] in row two actually defines the row’s third cell. Visually, the
table might be rendered to a tty device as:
-------------
| 1 | 2 | 3 |
----| |----
| 4 | | 6 |
----|---|----
| 7 | 8 | 9 |
-------------
Note that if the td [p.155] defining cell "6" had been omitted, an extra empty cell would have
been added by the user agent to complete the row.
- 158 -
XHTML™ 2.0 30.6.1. Cells that span several rows or columns
<td>2</td>
<td>3</td>
</tr>
<tr>
<td colspan="2">4</td>
<td>6</td>
</tr>
<tr>
<td>7</td>
<td>8</td>
<td>9</td>
</tr>
</tbody>
</table>
cell "4" spans two columns, so the second td [p.155] in the row actually defines the third cell
("6"):
-------------
| 1 | 2 | 3 |
--------|----
| 4 | 6 |
--------|----
| 7 | 8 | 9 |
-------------
Defining overlapping cells is an error. User agents may vary in how they handle this error (e.g.,
rendering may vary).
The following illegal example illustrates how one might create overlapping cells. In this table, cell
"5" spans two rows and cell "7" spans two columns, so there is overlap in the cell between "7"
and "9":
<table>
<tbody>
<tr>
<td>1</td>
<td>2</td>
<td>3</td>
</tr>
<tr>
<td>4</td>
<td rowspan="2">5</td>
<td>6</td>
</tr>
- 159 -
30.7. The thead and tfoot elements XHTML™ 2.0
<tr>
<td colspan="2">7</td>
<td>9</td>
</tr>
</tbody>
</table>
Table rows may be grouped into a table head, table foot, and one or more table body sections,
using the thead [p.160] , tfoot [p.160] and tbody [p.155] elements, respectively. This division
enables user agents to support scrolling of table bodies independently of the table head and
foot. When long tables are printed, the table head and foot information may be repeated on each
page that contains table data.
The table head and table foot should contain information about the table’s columns. The table
body must contain rows of table data.
When present, each thead [p.160] , tfoot [p.160] , and tbody [p.155] creates a row group. Each
row group must contain at least one row, defined by the tr [p.161] element.
If the thead [p.160] , tfoot [p.160] , and tbody [p.155] elements are used, and a rowspan attribute
is used within a group, the rowspan must remain within the group boundaries of which it is
defined.
This example illustrates the order and structure of the table head, foot, and bodies.
Example
<table>
<thead>
<tr> <em>...header information...</em></tr>
</thead>
<tfoot>
<tr> <em>...footer information...</em></tr>
</tfoot>
<tbody>
<tr> <em>...first row of block one data...</em></tr>
<tr> <em>...second row of block one data...</em></tr>
</tbody>
<tbody>
<tr> <em>...first row of block two data...</em></tr>
- 160 -
XHTML™ 2.0 30.8. The tr element
tfoot [p.160] must appear before tbody [p.155] within a table [p.145] definition so that user
agents can render the foot before receiving all of the (potentially numerous) rows of data.
This sample table contains three rows, each begun by the tr [p.161] element:
<table>
<caption>Cups of coffee consumed by each senator</caption>
<summary>This table charts the number of cups
of coffee consumed by each senator, the type
of coffee (decaf or regular), and whether
taken with sugar.</summary>
<tbody>
<tr> ...A header row...</tr>
<tr> ...First row of data...</tr>
<tr> ...Second row of data...</tr>
</tbody>
</table>
30.9. Issues
Why no nested colgroup or rowgroup? PR #7828
State: Open
Resolution: None
User: None
Notes:
- 161 -
30.9. Issues XHTML™ 2.0
Notes:
Group agress that the scope needs a better explanation.
Notes:
Agree that we need to tighten up the terminology.
Notes:
While there are notional "rowgroups" there are no explicit arbitrary rowgroups in HTML nor in
XHTML because rows are explicit in tables. colgroups, on the other hand, exist because HTML /
XHTML needs a way of referring to columns. Asked the submitter for more information and an
example including a description of what the advantages would be.
- 162 -
XHTML™ 2.0 31. XForms Module
The XForms Module provides a rich collection of forms features within the XHTML namespace.
XForms Core
model
XForms Form Controls
input | secret | textarea | output | upload | range | trigger | submit | select | select1
XForms Actions
action | dispatch | rebuild | recalculate | revalidate | refresh | setfocus | load | setvalue | send
| reset | message | insert | delete | setindex
XForms Group
group
XForms Switch
switch
XForms Repeat
repeat
The Text [p.51] content set is added to the XForms UI Inline content set, allowing various
XHTML elements inside form control labels.
- 163 -
31.4. Group XHTML™ 2.0
31.4. Group
When this module is included, the XForms Group content set is added to the Structural [p.43]
content set, and to the Text [p.51] content set.
The Structural [p.43] content set is added to the XForms Group content set.
31.5. Switch
When this module is included, the XForms Switch content set is added to the Structural [p.43]
content set, and to the Text [p.51] content set.
The Structural [p.43] content set is added to the content model of case, after an optional label
element.
31.6. Repeat
When this module is included, the XForms Repeat content set is added to the Structural [p.43]
content set, and to the Text [p.51] content set.
The Structural [p.43] content set is added to the content model of case, after an optional label
element.
- 164 -
XHTML™ 2.0 31.8. Other Attribute Collections
When this module is included, the XForms Repeat Attribute collection is included on all elements
that can validly appear twice or more as sibling elements.
The XForms Attribute Groups for single-node binding and Nodeset binding are allowed only on
the XForms elements they are defined for.
31.9. Issues
[XHTML2] exclude switch and case as presentational PR #7826
State: Open
Resolution: None
User: None
Notes:
Notes:
- 165 -
31.9. Issues XHTML™ 2.0
- 166 -
XHTML™ 2.0 32. XML Events Module
The XML Events Module defines a linkage between XHTML and the XML Document Object
Model [DOM [p.247] ]. XML Events are defined in [XMLEVENTS [p.249] ], and all XML Event
elements and attributes are in their own namespace.
32.1. Events
This module also defines the Events Attribute Collection via the global attributes from
[XMLEVENTS [p.249] ]. The normative definition of those attributes and their semantics is
included in that specification. They are described briefly below:
defaultAction = "cancel|perform"
This attribute defines whether or not the default action associated with the event should be
processed. The default value is perform
phase = "capture|default"
This attribute specifies the phase of event propagation in which to process the event. If not
specified, the default value of this attribute is default.
propagate = "stop|continue"
This attribute specifies whether an event should stop propagating after this observer
processes it, or continue for possible further processing. The default value of this attribute is
continue.
- 167 -
32.1. Events XHTML™ 2.0
Note that these attributes are not in the XHTML namespace but in the XML Events namespace.
The XHTML namespace is the default namespace for XHTML documents, so XHTML elements
and attributes may be expressed without namespace prefixes (although they are permitted on
elements). XML Events attributes MUST use a prefix, since they are not in the default
namespace of the document.
- 168 -
XHTML™ 2.0 A. Changes from XHTML 1.1
This Appendix describes the differences between XHTML 2.0 and XHTML 1.1.
- 169 -
A. Changes from XHTML 1.1 XHTML™ 2.0
- 170 -
XHTML™ 2.0 B. XHTML 2.0 RELAX NG Definition
This appendix contains the implementation of the XHTML 2.0 RELAX NG driver file.
<x:pre>
Copyright ©2003-2005 W3C® (MIT, ERCIM, Keio), All Rights Reserved.
<x:a href="http://www.w3.org/Consortium/Legal/copyright-software"
>http://www.w3.org/Consortium/Legal/copyright-software</x:a>
</x:pre>
<div>
<x:h2>XHTML 2.0 modules</x:h2>
<x:h3>Document Module</x:h3>
<include href="xhtml-document-2.rng"/>
<x:h3>Structural Module</x:h3>
<include href="xhtml-structural-2.rng"/>
<x:h3>Text Module</x:h3>
<include href="xhtml-text-2.rng"/>
<x:h3>Hypertext Module</x:h3>
<include href="xhtml-hypertext-2.rng"/>
<x:h3>List Module</x:h3>
<include href="xhtml-list-2.rng"/>
- 171 -
B.0.1. RELAX NG XHTML 2.0 Driver XHTML™ 2.0
<x:h3>Handler Module</x:h3>
<include href="xhtml-handler-2.rng"/>
<x:h3>Image Module</x:h3>
<include href="xhtml-image-2.rng"/>
<x:h3>Metainformation Module</x:h3>
<include href="xhtml-meta-2.rng"/>
<x:h3>Object Module</x:h3>
<include href="xhtml-object-2.rng"/>
<x:h3>Access Module</x:h3>
<include href="xhtml-access-2.rng"/>
<x:h3>Tables Module</x:h3>
<include href="xhtml-table-2.rng"/>
<x:h3>Support Modules</x:h3>
<x:h4>Datatypes Module</x:h4>
<include href="xhtml-datatypes-2.rng"/>
<x:h4>Param Module</x:h4>
<include href="xhtml-param-2.rng"/>
<x:h4>Caption Module</x:h4>
<include href="xhtml-caption-2.rng"/>
</div>
<div>
<x:h2>XML Events module</x:h2>
<include href="xml-events-1.rng"/>
</div>
<div>
<x:h2>Ruby module</x:h2>
<include href="full-ruby-1.rng">
<define name="Inline.class">
<notAllowed/>
</define>
<define name="NoRuby.content">
<ref name="Text.model"/>
</define>
</include>
<define name="Inline.model">
<notAllowed/>
- 172 -
XHTML™ 2.0 B.0.1. RELAX NG XHTML 2.0 Driver
</define>
<div>
<x:h2>XForms module</x:h2>
<include href="xforms-nons-11.rng"/>
<!--
<define name="XFORMS.Common.attrib" combine="interleave">
<ref name="Common.attrib"/>
</define>
-->
<div>
<x:h2>XML Schema instance module</x:h2>
<include href="XMLSchema-instance.rng"/>
</div>
</grammar>
- 173 -
B.0.1. RELAX NG XHTML 2.0 Driver XHTML™ 2.0
- 174 -
XHTML™ 2.0 C. XHTML RELAX NG Module Implementations
This appendix contains implementations of the modules defined in this specification. These
module implementations can be used in other XHTML Family Document Types.
<div>
<x:h2>Core Attributes Module</x:h2>
<include href="xhtml-core-attrib-2.rng"/>
</div>
<div>
<x:h2>Internationalization Attribute Module</x:h2>
<include href="xhtml-i18n-attrib-2.rng"/>
</div>
<div>
<x:h2>Bi-directional Text Collection</x:h2>
<include href="xhtml-bidi-attrib-2.rng"/>
</div>
<div>
<x:h2>Edit Attributes Module</x:h2>
<include href="xhtml-edit-attrib-2.rng"/>
</div>
<div>
<x:h2>Embedding Attributes Module</x:h2>
<include href="xhtml-embed-attrib-2.rng"/>
</div>
<div>
<x:h2>Events Module</x:h2>
<include href="xhtml-events-2.rng"/>
</div>
<div>
<x:h2>XForms Repeat Attribute Collection</x:h2>
<include href="xforms-repeat-attrib.rng"/>
- 175 -
C.1.2. Document XHTML™ 2.0
<div>
<x:h2>Hypertext Attributes Module</x:h2>
<include href="xhtml-hypertext-attrib-2.rng"/>
</div>
<div>
<x:h2>Image Map Attributes Module</x:h2>
<include href="xhtml-imagemap-attrib-2.rng"/>
</div>
<div>
<x:h2>Media Attribute Module</x:h2>
<include href="xhtml-media-attrib-2.rng"/>
</div>
<div>
<x:h2>Metainformation Attributes Module</x:h2>
<include href="xhtml-meta-attrib-2.rng"/>
</div>
<div>
<x:h2>Role Attribute Module</x:h2>
<include href="xhtml-role-attrib-2.rng"/>
</div>
<div>
<x:h2>Style Attribute Module</x:h2>
<include href="xhtml-inlstyle-2.rng"/>
</div>
<define name="Common.extra.attrib">
<empty/>
</define>
<define name="Common.attrib">
<ref name="Common.extra.attrib"/>
</define>
</grammar>
C.1.2. Document
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Document Module</x:h1>
<start>
<ref name="html"/>
- 176 -
XHTML™ 2.0 C.1.2. Document
</start>
<div>
<x:h2>The html element</x:h2>
<define name="html">
<element name="html">
<ref name="html.attlist"/>
<ref name="head"/>
<ref name="body"/>
</element>
</define>
<define name="html.attlist">
<ref name="Common.attrib"/>
<ref name="version.attrib"/>
<optional>
<ref name="XSI.schemaLocation"/>
</optional>
</define>
<define name="version.attrib">
<optional>
<attribute name="version">
<ref name="CDATA.datatype"/>
</attribute>
</optional>
</define>
</div>
<div>
<x:h2>The head element</x:h2>
<define name="head">
<element name="head">
<ref name="head.attlist"/>
<ref name="head.content"/>
</element>
</define>
<define name="head.attlist">
<ref name="Common.attrib"/>
</define>
<define name="head.content">
<ref name="title"/>
<zeroOrMore>
<choice>
<ref name="head.misc"/>
</choice>
</zeroOrMore>
</define>
<define name="head.misc">
<notAllowed/>
</define>
</div>
- 177 -
C.1.3. Structural XHTML™ 2.0
<div>
<x:h2>The title element</x:h2>
<define name="title">
<element name="title">
<ref name="title.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="title.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The body element</x:h2>
<define name="body">
<element name="body">
<ref name="body.attlist"/>
<ref name="Structural.model"/>
</element>
</define>
<define name="body.attlist">
<ref name="Common.attrib"/>
</define>
</div>
</grammar>
C.1.3. Structural
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Structural Module</x:h1>
<div>
<x:h2>The address element</x:h2>
<define name="address">
<element name="address">
<ref name="address.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="address.attlist">
<ref name="Common.attrib"/>
</define>
</div>
- 178 -
XHTML™ 2.0 C.1.3. Structural
<div>
<x:h2>The blockcode element</x:h2>
<define name="blockcode">
<element name="blockcode">
<ref name="blockcode.attlist"/>
<ref name="blockcode.content"/>
</element>
</define>
<define name="blockcode.attlist">
<ref name="Common.attrib"/>
</define>
<define name="blockcode.content">
<ref name="blockcode.model"/>
</define>
</div>
<div>
<x:h2>The blockquote element</x:h2>
<define name="blockquote">
<element name="blockquote">
<ref name="blockquote.attlist"/>
<ref name="blockquote.content"/>
</element>
</define>
<define name="blockquote.attlist">
<ref name="Common.attrib"/>
</define>
<define name="blockquote.content">
<ref name="blockquote.model"/>
</define>
</div>
<div>
<x:h2>The div element</x:h2>
<define name="div">
<element name="div">
<ref name="div.attlist"/>
<ref name="Flow.model"/>
</element>
</define>
<define name="div.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The heading elements</x:h2>
<define name="h">
- 179 -
C.1.3. Structural XHTML™ 2.0
<element name="h">
<ref name="Heading.attlist"/>
<ref name="Heading.content"/>
</element>
</define>
<define name="h1">
<element name="h1">
<ref name="Heading.attlist"/>
<ref name="Heading.content"/>
</element>
</define>
<define name="h2">
<element name="h2">
<ref name="Heading.attlist"/>
<ref name="Heading.content"/>
</element>
</define>
<define name="h3">
<element name="h3">
<ref name="Heading.attlist"/>
<ref name="Heading.content"/>
</element>
</define>
<define name="h4">
<element name="h4">
<ref name="Heading.attlist"/>
<ref name="Heading.content"/>
</element>
</define>
<define name="h5">
<element name="h5">
<ref name="Heading.attlist"/>
<ref name="Heading.content"/>
</element>
</define>
<define name="h6">
<element name="h6">
<ref name="Heading.attlist"/>
<ref name="Heading.content"/>
</element>
</define>
<define name="Heading.attlist">
<ref name="Common.attrib"/>
</define>
<define name="Heading.content">
<ref name="Text.model"/>
</define>
</div>
- 180 -
XHTML™ 2.0 C.1.3. Structural
<div>
<x:h2>The p element</x:h2>
<define name="p">
<element name="p">
<ref name="p.attlist"/>
<ref name="p.content"/>
</element>
</define>
<define name="p.attlist">
<ref name="Common.attrib"/>
</define>
<define name="p.content">
<ref name="p.model"/>
</define>
</div>
<div>
<x:h2>The pre element</x:h2>
<define name="pre">
<element name="pre">
<ref name="pre.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="pre.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The section element</x:h2>
<define name="section">
<element name="section">
<ref name="section.attlist"/>
<ref name="Flow.model"/>
</element>
</define>
<define name="section.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The separator element</x:h2>
<define name="separator">
<element name="separator">
<ref name="separator.attlist"/>
</element>
</define>
- 181 -
C.1.3. Structural XHTML™ 2.0
<define name="separator.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>Content Model</x:h2>
<define name="Heading.class">
<choice>
<ref name="h"/>
<ref name="h1"/>
<ref name="h2"/>
<ref name="h3"/>
<ref name="h4"/>
<ref name="h5"/>
<ref name="h6"/>
</choice>
</define>
<define name="Structural.class">
<choice>
<ref name="address"/>
<ref name="blockcode"/>
<ref name="blockquote"/>
<ref name="div"/>
<!--ref name="List.class"/-->
<ref name="p"/>
<ref name="pre"/>
<ref name="section"/>
<ref name="separator"/>
</choice>
</define>
<define name="blockcode.model">
<zeroOrMore>
<choice>
<text/>
<ref name="Text.class"/>
<ref name="Heading.class"/>
<ref name="Structural.class"/>
<ref name="List.class"/>
<ref name="Misc.class"/>
</choice>
</zeroOrMore>
</define>
<define name="blockquote.model">
<zeroOrMore>
<choice>
<text/>
<ref name="Text.class"/>
<ref name="Heading.class"/>
<ref name="Structural.class"/>
<ref name="List.class"/>
<ref name="Misc.class"/>
- 182 -
XHTML™ 2.0 C.1.3. Structural
</choice>
</zeroOrMore>
</define>
<define name="p.model">
<zeroOrMore>
<choice>
<text/>
<ref name="Text.class"/>
<ref name="List.class"/>
<ref name="blockcode"/>
<ref name="blockquote"/>
<ref name="pre"/>
<ref name="table"/>
<ref name="Misc.class"/>
</choice>
</zeroOrMore>
</define>
<define name="Structural.mix">
<zeroOrMore>
<choice>
<ref name="Heading.class"/>
<ref name="Structural.class"/>
<ref name="List.class"/>
<ref name="Misc.class"/>
</choice>
</zeroOrMore>
</define>
<define name="Structural.model">
<oneOrMore>
<ref name="Structural.mix"/>
</oneOrMore>
</define>
<define name="Flow.model">
<zeroOrMore>
<choice>
<text/>
<ref name="Heading.class"/>
<ref name="Structural.class"/>
<ref name="List.class"/>
<ref name="Text.class"/>
<ref name="Misc.class"/>
</choice>
</zeroOrMore>
</define>
</div>
</grammar>
- 183 -
C.1.4. Text XHTML™ 2.0
C.1.4. Text
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Text Module</x:h1>
<div>
<x:h2>The abbr element</x:h2>
<define name="abbr">
<element name="abbr">
<ref name="abbr.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="abbr.attlist">
<ref name="Common.attrib"/>
<optional>
<attribute name="full">
<ref name="URI.datatype"/>
</attribute>
</optional>
</define>
</div>
<div>
<x:h2>The cite element</x:h2>
<define name="cite">
<element name="cite">
<ref name="cite.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="cite.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The code element</x:h2>
<define name="code">
<element name="code">
<ref name="code.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="code.attlist">
<ref name="Common.attrib"/>
</define>
- 184 -
XHTML™ 2.0 C.1.4. Text
</div>
<div>
<x:h2>The dfn element</x:h2>
<define name="dfn">
<element name="dfn">
<ref name="dfn.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="dfn.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The em element</x:h2>
<define name="em">
<element name="em">
<ref name="em.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="em.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The kbd element</x:h2>
<define name="kbd">
<element name="kbd">
<ref name="kbd.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="kbd.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The l element</x:h2>
<define name="l">
<element name="l">
<ref name="l.attlist"/>
<ref name="Text.model"/>
</element>
</define>
- 185 -
C.1.4. Text XHTML™ 2.0
<define name="l.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The quote element</x:h2>
<define name="quote">
<element name="quote">
<ref name="quote.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="quote.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The samp element</x:h2>
<define name="samp">
<element name="samp">
<ref name="samp.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="samp.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The span element</x:h2>
<define name="span">
<element name="span">
<ref name="span.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="span.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The strong element</x:h2>
<define name="strong">
<element name="strong">
<ref name="strong.attlist"/>
<ref name="Text.model"/>
- 186 -
XHTML™ 2.0 C.1.4. Text
</element>
</define>
<define name="strong.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The sub element</x:h2>
<define name="sub">
<element name="sub">
<ref name="sub.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="sub.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The sup element</x:h2>
<define name="sup">
<element name="sup">
<ref name="sup.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="sup.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The var element</x:h2>
<define name="var">
<element name="var">
<ref name="var.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="var.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:p>these can occur at Structural or Text level</x:p>
<define name="Misc.class">
- 187 -
C.1.5. Hypertext XHTML™ 2.0
<empty/>
</define>
</div>
<div>
<x:h2>Content Model</x:h2>
<define name="Text.class">
<choice>
<ref name="abbr"/>
<ref name="cite"/>
<ref name="code"/>
<ref name="dfn"/>
<ref name="em"/>
<ref name="kbd"/>
<ref name="l"/>
<ref name="quote"/>
<ref name="samp"/>
<ref name="span"/>
<ref name="strong"/>
<ref name="sub"/>
<ref name="sup"/>
<ref name="var"/>
</choice>
</define>
<define name="Text.model">
<zeroOrMore>
<choice>
<text/>
<ref name="Text.class"/>
<ref name="Misc.class"/>
</choice>
</zeroOrMore>
</define>
</div>
</grammar>
C.1.5. Hypertext
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Hypertext Module</x:h1>
<div>
<x:h2>The a element</x:h2>
<define name="a">
<element name="a">
<ref name="a.attlist"/>
<ref name="Text.model"/>
</element>
</define>
- 188 -
XHTML™ 2.0 C.1.6. List
<define name="a.attlist">
<ref name="Common.attrib"/>
</define>
</div>
</grammar>
C.1.6. List
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>List Module</x:h1>
<div>
<x:h2>The dl element</x:h2>
<define name="dl">
<element name="dl">
<ref name="dl.attlist"/>
<optional>
<ref name="label-in-list"/>
</optional>
<choice>
<oneOrMore>
<choice>
<ref name="dt"/>
<ref name="dd"/>
</choice>
</oneOrMore>
<oneOrMore>
<ref name="di"/>
</oneOrMore>
</choice>
</element>
</define>
<define name="dl.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The di element</x:h2>
<define name="di">
<element name="di">
<ref name="di.attlist"/>
<oneOrMore>
<ref name="dt"/>
- 189 -
C.1.6. List XHTML™ 2.0
</oneOrMore>
<zeroOrMore>
<ref name="dd"/>
</zeroOrMore>
</element>
</define>
<define name="di.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The dt element</x:h2>
<define name="dt">
<element name="dt">
<ref name="dt.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="dt.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The dd element</x:h2>
<define name="dd">
<element name="dd">
<ref name="dd.attlist"/>
<ref name="Flow.model"/>
</element>
</define>
<define name="dd.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The label element</x:h2>
<define name="label-in-list">
<element name="label">
<ref name="label.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="label.attlist">
<ref name="Common.attrib"/>
</define>
</div>
- 190 -
XHTML™ 2.0 C.1.6. List
<div>
<x:h2>The nl element</x:h2>
<define name="nl">
<element name="nl">
<ref name="nl.attlist"/>
<ref name="label-in-list"/>
<oneOrMore>
<ref name="li"/>
</oneOrMore>
</element>
</define>
<define name="nl.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The ol element</x:h2>
<define name="ol">
<element name="ol">
<ref name="ol.attlist"/>
<optional>
<ref name="label-in-list"/>
</optional>
<oneOrMore>
<ref name="li-in-ol"/>
</oneOrMore>
</element>
</define>
<define name="ol.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The ul element</x:h2>
<define name="ul">
<element name="ul">
<ref name="ul.attlist"/>
<optional>
<ref name="label-in-list"/>
</optional>
<oneOrMore>
<ref name="li"/>
</oneOrMore>
</element>
</define>
<define name="ul.attlist">
<ref name="Common.attrib"/>
</define>
</div>
- 191 -
C.1.6. List XHTML™ 2.0
<div>
<x:h2>The li element</x:h2>
<define name="li">
<element name="li">
<ref name="li.attlist"/>
<ref name="Flow.model"/>
</element>
</define>
<define name="li.attlist">
<ref name="Common.attrib"/>
</define>
<define name="li-in-ol">
<element name="li">
<ref name="li-in-ol.attlist"/>
<ref name="Flow.model"/>
</element>
</define>
<define name="li-in-ol.attlist">
<ref name="Common.attrib"/>
<ref name="value.attrib"/>
</define>
<define name="value.attrib">
<optional>
<attribute name="value">
<ref name="Number.datatype"/>
</attribute>
</optional>
</define>
</div>
<div>
<x:h2>List Content Set</x:h2>
<define name="List.class">
<choice>
<ref name="dl"/>
<ref name="nl"/>
<ref name="ol"/>
<ref name="ul"/>
</choice>
</define>
</div>
</grammar>
- 192 -
XHTML™ 2.0 C.1.7. Core Attributes
<div>
<x:h2>Core Attribute Collection</x:h2>
<define name="class.attrib">
<optional>
<attribute name="class">
<ref name="NMTOKENS.datatype"/>
</attribute>
</optional>
</define>
<define name="id.attrib">
<optional>
<attribute name="xml:id">
<ref name="ID.datatype"/>
</attribute>
</optional>
</define>
<define name="layout.attrib">
<optional>
<attribute name="layout" a:defaultValue="irrelevant">
<choice>
<value>irrelevant</value>
<value>relevant</value>
</choice>
</attribute>
</optional>
</define>
<define name="title.attrib">
<optional>
<attribute name="title">
<ref name="Text.datatype"/>
</attribute>
</optional>
</define>
<define name="Core.attrib">
<ref name="id.attrib"/>
<ref name="class.attrib"/>
<ref name="layout.attrib"/>
<ref name="title.attrib"/>
</define>
</div>
- 193 -
C.1.8. Hypertext Attributes XHTML™ 2.0
<ref name="Core.attrib"/>
</define>
</grammar>
<div>
<x:h2>Hypertext Attributes Collection</x:h2>
<define name="cite.attrib">
<optional>
<attribute name="cite">
<ref name="URI.datatype"/>
</attribute>
</optional>
</define>
<define name="href.attrib">
<optional>
<attribute name="href">
<ref name="URI.datatype"/>
</attribute>
</optional>
</define>
<define name="hreflang.attrib">
<optional>
<attribute name="hreflang">
<ref name="LanguageCodes.datatype"/>
</attribute>
</optional>
</define>
<define name="hrefmedia.attrib">
<optional>
<attribute name="hrefmedia">
<ref name="MediaDesc.datatype"/>
</attribute>
</optional>
</define>
<define name="hreftype.attrib">
<optional>
<attribute name="hreftype">
<ref name="ContentTypes.datatype"/>
</attribute>
</optional>
</define>
- 194 -
XHTML™ 2.0 C.1.8. Hypertext Attributes
<define name="nextfocus.attrib">
<optional>
<attribute name="nextfocus">
<ref name="IDREF.datatype"/>
</attribute>
</optional>
</define>
<define name="prevfocus.attrib">
<optional>
<attribute name="prevfocus">
<ref name="IDREF.datatype"/>
</attribute>
</optional>
</define>
<define name="target.attrib">
<optional>
<attribute name="target">
<ref name="HrefTarget.datatype"/>
</attribute>
</optional>
</define>
<define name="base.attrib">
<optional>
<attribute name="xml:base">
<ref name="URI.datatype"/>
</attribute>
</optional>
</define>
<define name="Hypertext.attrib">
<ref name="cite.attrib"/>
<ref name="href.attrib"/>
<ref name="hreflang.attrib"/>
<ref name="hrefmedia.attrib"/>
<ref name="hreftype.attrib"/>
<ref name="nextfocus.attrib"/>
<ref name="prevfocus.attrib"/>
<ref name="target.attrib"/>
<ref name="base.attrib"/>
</define>
</div>
</grammar>
- 195 -
C.1.9. I18N Attribute XHTML™ 2.0
<div>
<x:h2>I18N Attribute Collection</x:h2>
<define name="lang.attrib">
<optional>
<attribute name="xml:lang">
<ref name="LanguageCode.datatype"/>
</attribute>
</optional>
</define>
<define name="I18n.attrib">
<ref name="lang.attrib"/>
</define>
</div>
</grammar>
C.1.10. Access
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Access Module</x:h1>
<div>
<x:h2>The access element</x:h2>
<define name="access">
<element name="access">
<ref name="access.attlist"/>
</element>
</define>
<define name="access.attlist">
<ref name="Common.attrib"/>
<optional>
<attribute name="key">
<ref name="Character.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="targetid">
- 196 -
XHTML™ 2.0 C.1.11. Bi-directional Text Attribute
<ref name="IDREF.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="targetrole">
<ref name="Role.datatype"/>
</attribute>
</optional>
</define>
</div>
</grammar>
<div>
<x:h2>Bi-directional Text Collection</x:h2>
<define name="dir.attrib">
<optional>
<attribute name="dir" a:defaultValue="ltr">
<choice>
<value>ltr</value>
<value>rtl</value>
<value>lro</value>
<value>rlo</value>
</choice>
</attribute>
</optional>
</define>
<define name="Bidi.attrib">
<ref name="dir.attrib"/>
</define>
</div>
</grammar>
- 197 -
C.1.12. Edit Attributes XHTML™ 2.0
<div>
<x:h2>Edit Collection</x:h2>
<define name="edit.attrib">
<optional>
<attribute name="edit">
<choice>
<value>inserted</value>
<value>deleted</value>
<value>changed</value>
<value>moved</value>
</choice>
</attribute>
</optional>
</define>
<define name="datetime.attrib">
<optional>
<attribute name="datetime">
<ref name="Datetime.datatype"/>
</attribute>
</optional>
</define>
<define name="Edit.attrib">
<ref name="edit.attrib"/>
<ref name="datetime.attrib"/>
</define>
</div>
</grammar>
<div>
<x:h2>Embedding Attributes Collection</x:h2>
<define name="src.attrib">
- 198 -
XHTML™ 2.0 C.1.14. Handler
<optional>
<attribute name="src">
<ref name="URI.datatype"/>
</attribute>
</optional>
</define>
<define name="srcencoding.attrib">
<optional>
<attribute name="srcencoding">
<ref name="Encodings.datatype"/>
</attribute>
</optional>
</define>
<define name="srctype.attrib">
<optional>
<attribute name="srctype">
<ref name="ContentTypes.datatype"/>
</attribute>
</optional>
</define>
<define name="Embedding.attrib">
<ref name="src.attrib"/>
<ref name="srcencoding.attrib"/>
<ref name="srctype.attrib"/>
</define>
</div>
<define name="Common.attrib" combine="interleave">
<ref name="Embedding.attrib"/>
</define>
</grammar>
C.1.14. Handler
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Handler Module</x:h1>
<div>
<x:h2>The handler element</x:h2>
<define name="handler">
<element name="handler">
<ref name="handler.attlist"/>
<choice>
<text/>
<ref name="handler"/>
</choice>
</element>
</define>
- 199 -
C.1.15. Image XHTML™ 2.0
<define name="handler.attlist">
<ref name="Common.attrib"/>
<optional>
<attribute name="type">
<ref name="ContentTypes.datatype"/>
</attribute>
</optional>
</define>
</div>
<define name="Handler.class">
<ref name="handler"/>
</define>
</grammar>
C.1.15. Image
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Image Module</x:h1>
<div>
<x:h2>The img element</x:h2>
<define name="img">
<element name="img">
<ref name="img.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="img.attlist">
<ref name="Common.attrib"/>
</define>
</div>
</grammar>
- 200 -
XHTML™ 2.0 C.1.16. Image Map Attributes
<div>
<x:h2>Image Map Attributes Collection</x:h2>
<define name="usemap.attrib">
<optional>
<attribute name="usemap">
<ref name="URI.datatype"/>
</attribute>
</optional>
</define>
<define name="ismap.attrib">
<optional>
<attribute name="ismap">
<value>ismap</value>
</attribute>
</optional>
</define>
<define name="shape.attrib">
<optional>
<attribute name="shape">
<ref name="Shape.datatype"/>
</attribute>
</optional>
</define>
<define name="coords.attrib">
<optional>
<attribute name="coords">
<ref name="Coordinates.datatype"/>
</attribute>
</optional>
</define>
<define name="Map.attrib">
<ref name="usemap.attrib"/>
<ref name="ismap.attrib"/>
<ref name="shape.attrib"/>
<ref name="coords.attrib"/>
</define>
</div>
</grammar>
- 201 -
C.1.17. Media Attribute XHTML™ 2.0
<define name="media.attrib">
<optional>
<attribute name="media" a:defaultValue="all">
<ref name="MediaDesc.datatype"/>
</attribute>
</optional>
</define>
</grammar>
<div>
<x:h2>Metadata Attribute Collection</x:h2>
<define name="about.attrib">
<optional>
<attribute name="about">
<ref name="URI.datatype"/>
</attribute>
</optional>
</define>
<define name="content.attrib">
<optional>
<attribute name="content">
<ref name="CDATA.datatype"/>
</attribute>
</optional>
</define>
<define name="datatype.attrib">
<optional>
<attribute name="datatype">
<ref name="QName.datatype"/>
</attribute>
- 202 -
XHTML™ 2.0 C.1.19. Metainformation
</optional>
</define>
<define name="property.attrib">
<optional>
<attribute name="property" a:defaultValue="reference">
<ref name="Property.datatype"/>
</attribute>
</optional>
</define>
<define name="rel.attrib">
<optional>
<attribute name="rel">
<ref name="LinkTypes.datatype"/>
</attribute>
</optional>
</define>
<define name="rev.attrib">
<optional>
<attribute name="rev">
<ref name="LinkTypes.datatype"/>
</attribute>
</optional>
</define>
<define name="Metadata.attrib">
<ref name="about.attrib"/>
<ref name="content.attrib"/>
<ref name="datatype.attrib"/>
<ref name="property.attrib"/>
<ref name="rel.attrib"/>
<ref name="rev.attrib"/>
</define>
</div>
</grammar>
C.1.19. Metainformation
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Metainformation Module</x:h1>
<div>
<x:h2>The link element</x:h2>
<define name="link">
<element name="link">
- 203 -
C.1.20. Object XHTML™ 2.0
<ref name="link.attlist"/>
<zeroOrMore>
<choice>
<ref name="link"/>
<ref name="meta"/>
</choice>
</zeroOrMore>
</element>
</define>
<define name="link.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The meta element</x:h2>
<define name="meta">
<element name="meta">
<ref name="meta.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="meta.attlist">
<ref name="Common.attrib"/>
</define>
</div>
</grammar>
C.1.20. Object
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Object Module</x:h1>
- 204 -
XHTML™ 2.0 C.1.20. Object
<x:p>Note. Also include the Caption Module when this module is used.</x:p>
<div>
<x:h2>The object element</x:h2>
<define name="object">
<element name="object">
<ref name="object.attlist"/>
<optional>
<ref name="caption"/>
</optional>
<optional>
<ref name="standby"/>
</optional>
<zeroOrMore>
<ref name="param"/>
</zeroOrMore>
<ref name="Flow.model"/>
</element>
</define>
<define name="object.attlist">
<ref name="Common.attrib"/>
<optional>
<attribute name="archive">
<ref name="URIs.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="content-length">
<ref name="Number.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="declare">
<value>declare</value>
</attribute>
</optional>
</define>
</div>
<div>
<x:h2>The standby element</x:h2>
<define name="standby">
<element name="standby">
<ref name="standby.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="standby.attlist">
<ref name="Common.attrib"/>
</define>
</div>
- 205 -
C.1.21. Role Access XHTML™ 2.0
<ref name="object"/>
</define>
</grammar>
<x:h1>Access Module</x:h1>
<div>
<x:h2>The access element</x:h2>
<define name="access">
<element name="access">
<ref name="access.attlist"/>
</element>
</define>
<define name="access.attlist">
<ref name="Common.attrib"/>
<optional>
<attribute name="key">
<ref name="Character.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="targetid">
<ref name="IDREF.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="targetrole">
<ref name="Role.datatype"/>
</attribute>
</optional>
</define>
</div>
</grammar>
- 206 -
XHTML™ 2.0 C.1.23. Style Sheet
<define name="style.attrib">
<optional>
<attribute name="style"/>
</optional>
</define>
</grammar>
<x:h1>Style Module</x:h1>
<div>
<x:h2>The style element</x:h2>
<define name="style">
<element name="style">
<ref name="style.attlist"/>
<text/>
</element>
</define>
<define name="style.attlist">
<ref name="Common.attrib"/>
<optional>
<attribute name="disabled">
<value>disabled</value>
</attribute>
</optional>
</define>
</div>
</grammar>
C.1.24. Tables
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:a="http://relaxng.org/ns/compatibility/annotations/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Tables Module</x:h1>
<x:p>Note. Also include the Caption Module when this module is used.</x:p>
- 207 -
C.1.24. Tables XHTML™ 2.0
<div>
<x:h2>The table element</x:h2>
<define name="table">
<element name="table">
<ref name="table.attlist"/>
<optional>
<ref name="caption"/>
</optional>
<optional>
<ref name="summary"/>
</optional>
<choice>
<zeroOrMore>
<ref name="col"/>
</zeroOrMore>
<zeroOrMore>
<ref name="colgroup"/>
</zeroOrMore>
</choice>
<choice>
<group>
<optional>
<ref name="thead"/>
</optional>
<optional>
<ref name="tfoot"/>
</optional>
<oneOrMore>
<ref name="tbody"/>
</oneOrMore>
</group>
<oneOrMore>
<ref name="tr"/>
</oneOrMore>
</choice>
</element>
</define>
<define name="table.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The summary element</x:h2>
<define name="summary">
<element name="summary">
<ref name="summary.attlist"/>
<ref name="Flow.model"/>
</element>
</define>
<define name="summary.attlist">
<ref name="Common.attrib"/>
- 208 -
XHTML™ 2.0 C.1.24. Tables
</define>
</div>
<div>
<x:h2>The col element</x:h2>
<define name="col">
<element name="col">
<ref name="col.attlist"/>
</element>
</define>
<define name="col.attlist">
<ref name="Common.attrib"/>
<ref name="span.attrib"/>
</define>
</div>
<div>
<x:h2>The colgroup element</x:h2>
<define name="colgroup">
<element name="colgroup">
<ref name="colgroup.attlist"/>
<zeroOrMore>
<ref name="col"/>
</zeroOrMore>
</element>
</define>
<define name="colgroup.attlist">
<ref name="Common.attrib"/>
<ref name="span.attrib"/>
</define>
</div>
<div>
<x:h2>The thead element</x:h2>
<define name="thead">
<element name="thead">
<ref name="thead.attlist"/>
<oneOrMore>
<ref name="tr"/>
</oneOrMore>
</element>
</define>
<define name="thead.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The tfoot element</x:h2>
<define name="tfoot">
- 209 -
C.1.24. Tables XHTML™ 2.0
<element name="tfoot">
<ref name="tfoot.attlist"/>
<oneOrMore>
<ref name="tr"/>
</oneOrMore>
</element>
</define>
<define name="tfoot.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The tbody element</x:h2>
<define name="tbody">
<element name="tbody">
<ref name="tbody.attlist"/>
<oneOrMore>
<ref name="tr"/>
</oneOrMore>
</element>
</define>
<define name="tbody.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The tr element</x:h2>
<define name="tr">
<element name="tr">
<ref name="tr.attlist"/>
<oneOrMore>
<choice>
<ref name="th"/>
<ref name="td"/>
</choice>
</oneOrMore>
</element>
</define>
<define name="tr.attlist">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:h2>The th element</x:h2>
<define name="th">
<element name="th">
<ref name="th.attlist"/>
<ref name="Flow.model"/>
- 210 -
XHTML™ 2.0 C.1.24. Tables
</element>
</define>
<define name="th.attlist">
<ref name="Cell.attrib"/>
</define>
</div>
<div>
<x:h2>The td element</x:h2>
<define name="td">
<element name="td">
<ref name="td.attlist"/>
<ref name="Flow.model"/>
</element>
</define>
<define name="td.attlist">
<ref name="Cell.attrib"/>
</define>
</div>
<div>
<x:h2>Attribute definitions</x:h2>
<define name="span.attrib">
<optional>
<attribute name="span" a:defaultValue="1">
<ref name="spanNumber.datatype"/>
</attribute>
</optional>
</define>
<define name="Cell.attrib">
<ref name="Common.attrib"/>
<optional>
<attribute name="abbr">
<ref name="Text.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="axis"/>
</optional>
<optional>
<attribute name="colspan" a:defaultValue="1">
<ref name="Number.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="headers">
<ref name="IDREFS.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="rowspan" a:defaultValue="1">
<ref name="Number.datatype"/>
- 211 -
C.2. XHTML RELAX NG Support Modules XHTML™ 2.0
</attribute>
</optional>
<ref name="scope.attrib"/>
</define>
<define name="scope.attrib">
<optional>
<attribute name="scope">
<choice>
<value>row</value>
<value>col</value>
<value>rowgroup</value>
<value>colgroup</value>
</choice>
</attribute>
</optional>
</define>
</div>
</grammar>
C.2.1. Datatypes
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:x="http://www.w3.org/1999/xhtml"
datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
<x:h1>Datatypes Module</x:h1>
<div>
<x:h2>Datatypes defined in XML 1.0</x:h2>
<define name="CDATA.datatype">
<text/>
</define>
<define name="ID.datatype">
<data type="ID"/>
</define>
<define name="IDREF.datatype">
<data type="IDREF"/>
</define>
- 212 -
XHTML™ 2.0 C.2.1. Datatypes
<define name="IDREFS.datatype">
<data type="IDREFS"/>
</define>
<define name="NAME.datatype">
<data type="Name"/>
</define>
<define name="NMTOKEN.datatype">
<data type="NMTOKEN"/>
</define>
<define name="NMTOKENS.datatype">
<data type="NMTOKENS"/>
</define>
</div>
<div>
<x:h2>Additional Datatypes</x:h2>
<define name="Character.datatype">
<x:p>A single character, as per section 2.2 of [XML].</x:p>
<data type="string">
<param name="length">1</param>
</data>
</define>
<define name="Encodings.datatype">
<x:p>A comma-separated list of ’charset’s with optional q parameters,
as defined in section 14.2 of [RFC2616] as the field value of
the Accept-Charset request header.</x:p>
<text/>
</define>
<define name="ContentTypes.datatype">
<x:p>A list of media ranges with optional accept parameters,
as defined in section 14.1 of [RFC2616] as the field value
of the accept request header.</x:p>
<text/>
</define>
<define name="Coordinates.datatype">
<x:p>Comma separated list of Lengths used in defining areas.</x:p>
<data type="string">
<param name="pattern">(\d+|\d+(\.\d+)?%)(,\s*(\d+|\d+(\.\d+)?%))*</param>
</data>
</define>
<define name="Datetime.datatype">
<x:p>Date and time information, as defined by the type dateTime
in [XMLSCHEMA].</x:p>
<data type="dateTime"/>
</define>
<define name="HrefTarget.datatype">
<x:p>Name used as destination for results of certain actions.</x:p>
- 213 -
C.2.1. Datatypes XHTML™ 2.0
<ref name="NMTOKEN.datatype"/>
</define>
<define name="LanguageCode.datatype">
<x:p>A language code, as per [RFC3066].</x:p>
<data type="language"/>
</define>
<define name="LanguageCodes.datatype">
<x:p>A comma-separated list of language ranges.</x:p>
<text/>
</define>
<define name="Length.datatype">
<x:p>The value may be either in pixels or a percentage of the available
horizontal or vertical space. Thus, the value "50%" means half of
the available space.</x:p>
<data type="string">
<param name="pattern">(\d+|\d+(\.\d+)?%)</param>
</data>
</define>
<define name="LocationPath.datatype">
<x:p>A location path as defined in [XPATH].</x:p>
<text/>
</define>
<define name="LinkTypes.datatype">
<x:p>The value is a QName.</x:p>
<choice>
<value>alternate</value>
<value>start</value>
<value>next</value>
<value>prev</value>
<value>up</value>
<value>contents</value>
<value>index</value>
<value>glossary</value>
<value>copyright</value>
<value>chapter</value>
<value>section</value>
<value>subsection</value>
<value>appendix</value>
<value>help</value>
<value>bookmark</value>
<value>meta</value>
<value>icon</value>
<value>p3pv1</value>
<value>profile</value>
<value>role</value>
<value>cite</value>
<ref name="QName.datatype"/>
</choice>
</define>
<define name="MediaDesc.datatype">
<x:p>A comma-separated list of media descriptors as described by [CSS].
- 214 -
XHTML™ 2.0 C.2.1. Datatypes
<define name="Number.datatype">
<x:p>One or more digits (NUMBER).</x:p>
<data type="nonNegativeInteger">
<param name="pattern">[0-9]+</param>
</data>
</define>
<define name="spanNumber.datatype">
<x:p>span: this attribute value must be an integer > 0;
the default value is 1.</x:p>
<data type="positiveInteger">
<param name="pattern">[0-9]+</param>
</data>
</define>
<define name="QName.datatype">
<x:p>An [XMLNS]-qualified name.</x:p>
<data type="QName"/>
</define>
<define name="QNames.datatype">
<x:p>One or more white space separated QName values.</x:p>
<list>
<oneOrMore>
<data type="QName"/>
</oneOrMore>
</list>
</define>
<define name="prefixedQName.datatype">
<x:p>An [XMLNS]-qualified name.</x:p>
<data type="QName">
<param name="pattern">[\i-[:]][\c-[:]]*:[\i-[:]][\c-[:]]*</param>
</data>
</define>
<define name="Property.datatype">
<x:p>The value is a QName.</x:p>
<choice>
<value>reference</value>
<value>description</value>
<value>generator</value>
<value>keywords</value>
<value>robots</value>
<value>title</value>
<ref name="prefixedQName.datatype"/>
</choice>
</define>
<define name="Role.datatype">
<x:p>The value is a list of QNames.</x:p>
- 215 -
C.2.2. Events XHTML™ 2.0
<list>
<oneOrMore>
<choice>
<value>main</value>
<value>secondary</value>
<value>navigation</value>
<value>banner</value>
<value>contentinfo</value>
<value>note</value>
<value>seealso</value>
<value>search</value>
<ref name="prefixedQName.datatype"/>
</choice>
</oneOrMore>
</list>
</define>
<define name="Shape.datatype">
<x:p>The shape of a region.</x:p>
<choice>
<value>default</value>
<value>rect</value>
<value>circle</value>
<value>poly</value>
</choice>
</define>
<define name="Text.datatype">
<x:p>Arbitrary textual data, likely meant to be human-readable.</x:p>
<text/>
</define>
<define name="URI.datatype">
<x:p>A Uniform Resource Identifier Reference, as defined by the type
anyURI in [XMLSCHEMA].</x:p>
<data type="anyURI"/>
</define>
<define name="URIs.datatype">
<x:p>A space-separated list of URIs as defined above.</x:p>
<list>
<oneOrMore>
<data type="anyURI"/>
</oneOrMore>
</list>
</define>
</div>
</grammar>
C.2.2. Events
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:ev="http://www.w3.org/2001/xml-events"
xmlns:a="http://relaxng.org/ns/compatibility/annotations/1.0"
- 216 -
XHTML™ 2.0 C.2.2. Events
xmlns:x="http://www.w3.org/1999/xhtml">
<define name="Events.attrib">
<optional>
<attribute name="ev:event">
<ref name="NMTOKEN.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="ev:observer">
<ref name="IDREF.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="ev:target">
<ref name="IDREF.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="ev:handler">
<ref name="URI.datatype"/>
</attribute>
</optional>
<optional>
<attribute name="ev:phase" a:defaultValue="default">
<choice>
<value>capture</value>
<value>default</value>
</choice>
</attribute>
</optional>
<optional>
<attribute name="ev:propagate" a:defaultValue="continue">
<choice>
<value>stop</value>
<value>continue</value>
</choice>
</attribute>
</optional>
<optional>
<attribute name="ev:defaultAction" a:defaultValue="perform">
<choice>
<value>cancel</value>
<value>perform</value>
</choice>
</attribute>
</optional>
</define>
- 217 -
C.2.3. Param XHTML™ 2.0
</define>
<!--
<define name="Misc.class" combine="choice">
<ref name="listener" ns="http://www.w3.org/2001/xml-events"/>
</define>
-->
</grammar>
C.2.3. Param
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:a="http://relaxng.org/ns/compatibility/annotations/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Param Module</x:h1>
<div>
<x:h2>The param element</x:h2>
<define name="param">
<element name="param">
<ref name="param.attlist"/>
</element>
</define>
<define name="param.attlist">
<optional>
<ref name="id.attrib"/>
</optional>
<attribute name="name"/>
<optional>
<attribute name="value"/>
</optional>
<optional>
<attribute name="valuetype" a:defaultValue="data">
<choice>
<value>data</value>
<value>ref</value>
<value>object</value>
</choice>
</attribute>
</optional>
<optional>
<attribute name="type">
<ref name="ContentTypes.datatype"/>
</attribute>
</optional>
</define>
</div>
</grammar>
- 218 -
XHTML™ 2.0 C.3. RELAX NG External Modules
C.2.4. Caption
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:a="http://relaxng.org/ns/compatibility/annotations/1.0"
xmlns:x="http://www.w3.org/1999/xhtml">
<x:h1>Caption Module</x:h1>
<div>
<x:h2>The caption element</x:h2>
<define name="caption">
<element name="caption">
<ref name="caption.attlist"/>
<ref name="Text.model"/>
</element>
</define>
<define name="caption.attlist">
<ref name="Common.attrib"/>
</define>
</div>
</grammar>
<define name="role.attrib">
<optional>
<attribute name="role">
<ref name="Role.datatype"/>
</attribute>
</optional>
</define>
</grammar>
- 219 -
C.3.1. Ruby XHTML™ 2.0
C.3.1. Ruby
<?xml version="1.0" encoding="UTF-8"?>
<grammar xmlns="http://relaxng.org/ns/structure/1.0"
xmlns:a="http://relaxng.org/ns/compatibility/annotations/1.0"
xmlns:x="http://www.w3.org/1999/xhtml"
datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
<x:pre>
Ruby Elements
http://www.w3.org/TR/ruby
<x:a href="http://www.w3.org/Consortium/Legal/copyright-software"
>http://www.w3.org/Consortium/Legal/copyright-software</x:a>
</x:pre>
<div>
<x:h2>patterns for the content model of the ruby element</x:h2>
<define name="Ruby.content.simple">
<x:p>Content model of simple ruby</x:p>
<group>
<ref name="rb"/>
<choice>
<ref name="rt-simple"/>
<group>
<ref name="rp"/>
<ref name="rt-simple"/>
<ref name="rp"/>
</group>
</choice>
</group>
</define>
- 220 -
XHTML™ 2.0 C.3.1. Ruby
<define name="Ruby.content.complex">
<x:p>Content model of complex ruby</x:p>
<group>
<ref name="rbc"/>
<ref name="rtc"/>
<optional>
<ref name="rtc"/>
</optional>
</group>
</define>
<define name="Ruby.content">
<x:p>Simple ruby is used by default</x:p>
<ref name="Ruby.content.simple"/>
</define>
</div>
<div>
<x:h2>Ruby Elements</x:h2>
<x:h3>ruby element</x:h3>
<define name="ruby">
<element name="ruby">
<ref name="Ruby.content"/>
<ref name="Ruby.common.attrib"/>
</element>
</define>
<define name="rbc">
<element name="rbc">
<oneOrMore>
<ref name="rb"/>
</oneOrMore>
<ref name="Ruby.common.attrib"/>
</element>
</define>
<define name="rtc">
<element name="rtc">
<oneOrMore>
<ref name="rt-complex"/>
</oneOrMore>
<ref name="Ruby.common.attrib"/>
</element>
</define>
<define name="rb">
<element name="rb">
<ref name="NoRuby.content"/>
- 221 -
C.3.1. Ruby XHTML™ 2.0
<ref name="Ruby.common.attrib"/>
</element>
</define>
<define name="rt-simple">
<x:p>grammar for simple ruby</x:p>
<x:p>rbspan attribute is not allowed in simple ruby</x:p>
<element name="rt">
<ref name="NoRuby.content"/>
<ref name="Ruby.common.attrib"/>
</element>
</define>
<define name="rt-complex">
<x:p>grammar for complex ruby</x:p>
<element name="rt">
<ref name="NoRuby.content"/>
<ref name="Ruby.common.attrib"/>
<optional>
<attribute name="rbspan" a:defaultValue="1">
<data type="positiveInteger">
<param name="pattern">[1-9][0-9]*</param>
</data>
</attribute>
</optional>
</element>
</define>
<define name="rp">
<element name="rp">
<text/>
<ref name="Ruby.common.attrib"/>
</element>
</define>
</div>
<div>
<x:h2>Ruby Common Attributes</x:h2>
<define name="Ruby.common.attrib">
<ref name="Common.attrib"/>
</define>
</div>
<div>
<x:p>Content models of the rb and the rt elements are intended to
allow other inline-level elements of its parent markup language,
but it should not include ruby descendent elements. This RELAX NG
module itself doesn’t check nesting of ruby elements.
- 222 -
XHTML™ 2.0 C.3.2. Ruby Driver for Full Ruby Markup
<define name="NoRuby.content">
<ref name="Inline.model"/>
</define>
</div>
</grammar>
<x:pre>
Copyright ©2003 W3C® (MIT, ERCIM, Keio), All Rights Reserved.
<include href="ruby-1.rng"/>
</grammar>
<x:pre>
Copyright ©2003 W3C® (MIT, ERCIM, Keio), All Rights Reserved.
- 223 -
C.3.3. XML Events XHTML™ 2.0
<x:a href="http://www.w3.org/Consortium/Legal/copyright-software"
>http://www.w3.org/Consortium/Legal/copyright-software</x:a>
</x:pre>
<define name="listener">
<element name="listener">
<ref name="listener.attlist"/>
</element>
</define>
<define name="listener.attlist">
<optional>
<attribute name="event">
<data type="NMTOKEN"/>
</attribute>
</optional>
<optional>
<attribute name="observer">
<data type="IDREF"/>
</attribute>
</optional>
<optional>
<attribute name="target">
<data type="IDREF"/>
</attribute>
</optional>
<optional>
<attribute name="handler">
<data type="anyURI"/>
</attribute>
</optional>
<optional>
<attribute name="phase" a:defaultValue="default">
<choice>
<value>capture</value>
<value>default</value>
</choice>
</attribute>
</optional>
<optional>
<attribute name="propagate" a:defaultValue="continue">
<choice>
<value>stop</value>
<value>continue</value>
</choice>
</attribute>
</optional>
- 224 -
XHTML™ 2.0 C.3.4. XML Schema instance
<optional>
<attribute name="defaultAction" a:defaultValue="perform">
<choice>
<value>cancel</value>
<value>perform</value>
</choice>
</attribute>
</optional>
<optional>
<attribute name="id">
<data type="ID"/>
</attribute>
</optional>
</define>
</grammar>
<define name="XSI.type">
<attribute name="xsi:type">
<data type="QName"/>
</attribute>
</define>
<define name="XSI.nil">
<attribute name="xsi:nil">
<data type="boolean"/>
</attribute>
</define>
<define name="XSI.schemaLocation">
<attribute name="xsi:schemaLocation">
<list>
<oneOrMore>
<data type="anyURI"/>
<data type="anyURI"/>
</oneOrMore>
</list>
</attribute>
</define>
<define name="XSI.noNamespaceSchemaLocation">
<attribute name="xsi:noNamespaceSchemaLocation">
<data type="anyURI"/>
</attribute>
</define>
</grammar>
- 225 -
C.3.4. XML Schema instance XHTML™ 2.0
- 226 -
XHTML™ 2.0 D. XHTML 2.0 Schema
This appendix will contain the implementation of the XHTML 2.0 Schema driver file and content
model file.
- 227 -
D. XHTML 2.0 Schema XHTML™ 2.0
- 228 -
XHTML™ 2.0 E. XHTML Schema Module Implementations
This appendix will contain implementations of the modules defined in this specification via XML
Schema [XMLSCHEMA [p.249] ].
- 229 -
E. XHTML Schema Module Implementations XHTML™ 2.0
- 230 -
XHTML™ 2.0 F. XHTML 2.0 Document Type Definition
This appendix will contain the implementation of the XHTML 2.0 DTD driver file and content
model file.
F.1. Issues
Entity management: do we still need it? PR #670
State: Approved
Resolution: Accepted
User: Agree
Notes:
We will support both XML Catalogs and SGML Open Catalogs for XHTML 2.
Notes:
The WG believes that there’s still a need for character entities. We need to find a solution. On 9
September 2003, the WG agrees to retain character entities; DTDs therefore still necessary; it
might be possible to supply a DTD that only provides the entities.
- 231 -
F.1. Issues XHTML™ 2.0
- 232 -
XHTML™ 2.0 G. XHTML DTD Module Implementations
This appendix will contain implementations of the modules defined in this specification. These
module implementations can be used in other XHTML Family Document Types.
Note that the module above references a content model module. This module is defined on a
per-document type basis in addition to the document type driver file.
- 233 -
G.3. XHTML DTD Support Modules XHTML™ 2.0
- 234 -
XHTML™ 2.0 H. Style sheet for XHTML 2
This Appendix defines a normative [CSS2 [p.247] ] style sheet for XHTML 2. While visual user
agents implementing XHTML 2 are not required to support CSS2, their default behavior should
be as if the following CSS2 styles are in effect. Note that this default behavior can be overridden
by any number of things - including, for example, user-defined preferences.
@namespace url("http://www.w3.org/2002/06/xhtml2/");
/* new elements */
section h, h2 {
font-size: 1.5em;
margin: .83em 0;
}
section section h, h3 {
font-size: 1.17em;
margin: 1em 0;
}
- 235 -
H. Style sheet for XHTML 2 XHTML™ 2.0
line-height: 1.17em;
margin: 1.67em 0;
}
nl {
height: 1.5em;
overflow: hidden;
margin: 0;
line-height: normal !important;
white-space: nowrap;
text-align: start;
cursor: default;
border-width: 2px !important;
border-style: inset !important;
vertical-align: baseline;
padding: 0;
}
nl > nl > li {
- 236 -
XHTML™ 2.0 H. Style sheet for XHTML 2
padding-left: 2em;
font-style: normal;
font-weight: normal;
}
/* inherited elements */
- 237 -
H. Style sheet for XHTML 2 XHTML™ 2.0
/* block-level elements */
body, div, p, hr, h1, h2, h3, h4, h5, h6,
address, blockquote, pre, ol, ul, li, di, dt, dd,
table, thead, tbody, tfoot, tr, td, th,
col, colgroup, caption, object, summary, standby, blockcode
{ unicode-bidi: embed }
/* end bidi settings */
/* end xhtml2.css */
- 238 -
XHTML™ 2.0 I. Example RDF Specification for Roles
This Appendix will define an example RDF specification for the XHTML 2 namespace role
attribute values.
- 239 -
I. Example RDF Specification for Roles XHTML™ 2.0
- 240 -
XHTML™ 2.0 J. List of Elements
J. List of Elements
This appendix is informative.
This appendix will contain a list of elements defined in this specification, sorted in alphabetical
order, with some other relevant information and links to the element definitions.
- 241 -
J. List of Elements XHTML™ 2.0
- 242 -
XHTML™ 2.0 K. List of Attributes
K. List of Attributes
This appendix is informative.
- 243 -
K. List of Attributes XHTML™ 2.0
- 244 -
XHTML™ 2.0 L. Cross-reference Index
L. Cross-reference Index
This appendix is informative.
This appendix will contain a detailed index of this document, with links to the indexed terms.
- 245 -
L. Cross-reference Index XHTML™ 2.0
- 246 -
XHTML™ 2.0 M. References
M. References
This appendix is normative.
- 247 -
M.1. Normative References XHTML™ 2.0
- 248 -
XHTML™ 2.0 M.2. Informative References
- 249 -
M.2. Informative References XHTML™ 2.0
- 250 -
XHTML™ 2.0 N. Acknowledgements
N. Acknowledgements
This appendix is informative.
This specification was prepared by the W3C HTML Working Group. The participants at the time
of publication were:
The HTML Working Group would like to acknowledge the great many people outside of the
HTML Working Group who help with the process of developing the XHTML 2.0 specification.
These people are too numerous to list individually. They include but are not limited to people
who have contributed on the [email protected] mailing list, other Working Groups at the W3C,
and the W3C Team. XHTML 2.0 is truly a cooperative effort between the HTML Working Group,
the rest of the W3C, and the public.
- 251 -