Modularization of XHTML™ in XML Schema
W3C Working Draft 3 October 2003
- This version:
- http://www.w3.org/TR/2003/WD-xhtml-m12n-schema-20031003
- Latest version:
- http://www.w3.org/TR/xhtml-m12n-schema
- Previous version:
- http://www.w3.org/TR/2002/WD-xhtml-m12n-schema-20021209
- Diff-marked version:
- xhtml-m12n-schema-diff.html
- Editors:
- Daniel Austin, W. W. Grainger, Inc.
Subramanian Peruvemba, Oracle Corporation
Shane McCarron, Applied Testing and Technology, Inc.
Masayasu Ishikawa, W3C
This document is also available in these non-normative formats: Single XHTML file, PostScript version, PDF version, ZIP archive, and Gzip'd TAR archive.
Copyright © 2003
W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark, document use and software licensing rules apply.
Abstract
This document describes a methodology for modularization of XHTML using XML Schema. The document also provides a XML Schema implementation of the abstract modules defined in Modularization
of XHTML [XHTMLMOD].
Status of This Document
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the latest revision of
this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This is the Last Call Working Draft of "Modularization of XHTML™ in XML Schema" for review by members of the W3C
and other interested parties in the general public. It is a stand-alone document to ease its review. It is being re-submitted for last call because of substantial changes in the way the Schemas are
implemented to ease their use in non-XHTML contexts. After going through Last Call again, this document will be integrated into a new edition of Modularization of XHTML [XHTMLMOD]. The Last Call review period ends 14 November 2003.
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.
Patent disclosures relevant to this specification may be found on the Working Group's public patent disclosure page.
Please send review comments to www-html-editor@w3.org (archive). Public discussion on
XHTML takes place on the mailing list www-html@w3.org (archive).
This document has been produced by the W3C HTML Working Group (members
only) as part of the HTML Activity. The goals of the HTML Working Group are discussed in the
HTML Working Group charter.
Quick Table of Contents
Full Table of Contents
1. Introduction
This section is informative.
1.1. Purpose of this document
The purpose of this document is to describe a modularization framework for languages within the XHTML Namespace using XML Schema [XMLSCHEMA].
The Modularization of XHTML [XHTMLMOD] specifies well-defined sets of abstract modules that can be combined and extended allowing the
creation of a new XHTML-family document types that are portable among XHTML-family user agents. This document provides XML Schema implementation of the abstract modules defined in
Modularization of XHTML [XHTMLMOD]. In addition to the schema modules themselves, the framework presented here describes a means of further extending
and modifying XHTML.
To a large extent, the modularization framework presented here attempts to duplicate the modularization concepts used in XHTMLMOD. Here and throughout this document, the term "XHTMLMOD" is used
to refer to [XHTMLMOD]).
2. Terms and Definitions
This section is normative.
This document is the XML Schema implemantaion of abstract modules defined in XHTML Modularization [XHTMLMOD] and terms used in the document
are defined in Terms and Definitions section of XHTML Modularization [XHTMLMOD].
3. Conformance Definition
This section is normative.
This document is the XML Schema implemantaion of abstract modules defined in XHTML Modularization [XHTMLMOD] and defines conformance
requirements as defined in Conformance Definition section of XHTML Modularization [XHTMLMOD]
A. Building Schema Modules
This chapter is normative.
This chapter contains instructions on how to define XML Schema modules that are compatible with the XHTML Modularization implementation via XML Schema [XMLSCHEMA]. This is in an appendix so that it can be a drop in replacement for the corresponding appendix in XHTML Modularization [XHTMLMOD].
XHTML Schema modules are implemented as fragments. When these fragments are assembled in a specific manner (described in Developing Schemas
with defined and extended modules), the resulting Schema is a representation of a complete document type. This representation can then be used for validation of instances of the document
type.
The key to combining these fragments into a meaningful, cohesive Schema is the rules used to define the fragments. This section defines those rules. When these rules are followed, markup language
authors can be confident that their modules will interface cleanly with other XHTML-compatible modules.
Modules conforming to these rules also need to satisfy the conformance requirements defined in XHTML Family Module Conformance of XHTML Modularization [XHTMLMOD] in order to be called XHTML Family Modules.
A.1. Named Content Models
This specification classifies named content model into categories and names them consistently using the following suffixes
- .content
- model group definitions use the suffix
.content when they are used to represent the content model of an element type.
- .class
- model group definitions use the suffix
.class when they are used to represent elements of the same class.
- .mix
- model group definitions use the suffix
.mix when they are used to represent a collection of element types from different classes.
- .extra
- model group definitions use the suffix
.extra when they are used to extend other groups above.
- .type
- named complex type definitions use the suffix
.type when they are used to represent type of an element.
- .attlist
- attribute groups use the suffix
.attlist when they are used to represent the attributes for a specific element.
- .attrib
- attribute groups use the suffix
.attrib when they are used to represent a group of tokens representing one or more complete attribute specifications within an .attlist
declaration.
For example, in HTML 4, the %block; parameter entity is defined to represent the heterogeneous collection of element types that are block-level elements. In this specification, the
corollary named content model is Block.mix.
When defining named content model in the classes defined here, modules should scope the names of the model group definitions and attribute groups by using unique prefixes. For example, the content
model for the element myelement in the module mymodule could be named myelement.content. Other schemes are possible. Regardless of the scheme used, module authors should
strive to ensure that named content model they define are named uniquely so that they do not collide with other named content model and so that the interface methods for the module are obvious to its
users.
A.2. Defining the Namespace of a Module
XHTML requires that the elements and attributes declared in a module be within a defined XML namespace [XMLNAMES]. The identification of this namespace is
an arbitrary URI. XHTML requires that when a module is implemented using an XML Schema, the module declare its target namespace.
A.2.1. Global and Local Element Declarations
While XML Schema allows an the definition of global and local element declarations, to be compatible with DTD definitions of XHTML Modularization module implementations must not declare local
elements.
A.2.2. Global and Local Attribute Declarations
While the approach defined here permits the definition of global as well as attributes declarations, schema authors should consider the consequences of such definitions on an document instance.
Global attributes must always be explicitly prefixed in a instance document by declaring a namespace prefix xmlns:prefix, while local attributes depending on the schema implementation may be
be explicitly prefixed.
A.3. Content model Redefinitions
Quite often modules change the content model of elements defined by other modules. For example, XHTML Events module add event attributes to element defined by forms module. It is also possible
multiple modules may change the content model of a single element defined by a third module, for example both XHTML Events Module and XHTML Image Map module add attributes to elements in form
module.
XML Schemas allows for changes to a declared content model using the redefine element. While XML Schema supports redefine element that redefines the named content model and type
definition, XML Schema does not directly support redefintion of an element or attribute declaration.
To support element content model redefinitions,
- Schema module implementations must define the content model of an element using named complex types schema component
.type. Further the named schema types must be defined in terms of
named content model .content and .attlist
- redefine in XML Schema by default includes of the referenced schema, hence module implementations must not directly redefine content model of other modules in its implementation. The
redefining module must declare the named content models (model group defintions and/or attribute groups) that may be used for redefinitions by the schema that defines the document model
- Finally, the schema defining document model (of the new document type) may redefine the content model of modules. The redefinitions define the new content model of an included element that
comprise the named content models defined in both the redefined module and redefining module.
B. Developing Schema with defined and extended modules
This chapter is informative.
The primary purpose of defining XHTML modules and a general modularization methodology is to ease the development of document types that are based upon XHTML. These document types may extend XHTML
by integrating additional capabilities (e.g., [SMIL]), or they may define a subset of XHTML for use in a specialized device. This section describes the
techniques that document type designers must use in order to take advantage of the XML Schema implementation of this modularization architecture. It does this by applying the XHTML Modularization
techniques in progressively more complex ways, culminating in the creation of a complete document type from disparate modules.
Note that in no case do these examples require the modification of the XHTML-provided module file entities themselves. The XHTML module file entities are completely parameterized, so that
it is possible through separate module definitions and driver files to customize the definition and the content model of each element and each element's hierarchy.
Finally, remember that most users of XHTML are not expected to be XML Schema authors. XML Schema authors are generally people who are defining specialized markup that will improve the
readability, simplify the rendering of a document, or ease machine-processing of documents, or they are client designers that need to define the specialized markup language for their specific client.
Consider these cases:
-
An organization is providing subscriber's information via a Web interface. The organization stores its subscriber information in an XML-based database. One way to report that information out from
the database to the Web is to embed the XML records from the database directly in the XHTML document. While it is possible to merely embed the records, the organization could define a module that
describes the records, attach that module to an XHTML implementation, and thereby create a complete markup language for the pages. The organization can then access the data within the new elements
via the Document Object Model [DOM], validate the documents, provide style definitions for the elements that cascade using Cascading Style Sheets [CSS2], etc. By taking the time to define the structure of their data and create a markup language using the processes defined in this section, the organization can
realize the full benefits of XML.
-
An Internet client developer is designing a specialized device. That device will only support a subset of XHTML, and the devices will always access the Internet via a proxy server that validates
content before passing it on to the client (to minimize error handling on the client). In order to ensure that the content is valid, the developer creates a markup language that is a subset of XHTML
using the processes defined in this section. They then use the new language definition in their proxy server and in their devices, and also make the language definition available to content
developers so that developers can validate their content before making it available. By performing a few simple steps, the client developer can use the architecture defined in this document to
greatly ease their language development cost and ensure that they are fully supporting the subset of XHTML that they choose to include.
B.1. Defining additional attributes
In some cases, an extension to XHTML can be as simple as additional attributes. Schema authors should an provide the attribute definitions for each attribute, for example:
<xs:attributeGroup name="myattrs.attrib">
<xs:attribute name="myattribute" type="xs:string"/>
</xs:attributeGroup>
would declare an attribute "myattr" and attribute group "myattrs.attrib" in the target namespace of the schema ("xs" is the prefix for XML Schema Namespace). Authors should note that the attribute
is created as local attribute (as part attribute group) Alternatively, declaring an attribute by placing the attribute declaration as direct child of schema element creates an Global
attribute (and would require the document instances to use a qualified attribute names such as xlink:show). For a discussion of qualified names and Namespace prefixes, see Defining the Namespace of a Module.
To add this attribute to the content model of an element, the attribute group (that makes the content model of the element) would need to be redefined to include the new attribute. for
example:
<xs:redefine schemaLocation="xhtml-hypertext-1.xsd">
<xs:attributeGroup name="xhtml:a.attlist">
<xs:attributeGroup ref="xhtml:a.attlist"/>
<xs:attributeGroup ref="myml:myattrs.attrib"/>
</xs:attributeGroup>
</xs:redefine>
where "xhtml" is the prefix for XHTML Namespace. The schema modularization requires such redefinitions be defined as part of the markup language definition and the strategies for those are
addressed in the later sections. Naturally, adding an attribute to a schema does not mean that any new behavior is defined for arbitrary clients. However, a content developer could use an extra
attribute to store information that is accessed by associated scripts via the Document Object Model (for example).
B.2. Defining additional elements
Defining additional elements is similar to attributes, but a typical XHTML module would define the element as a global element (as a direct child of schema element) Schema authors should
first write the element declaration for each element:
<!-- In the myml-module-1.xsd -->
<xs:group name="myelement.content">
<xs:choice>
<xs:element ref="myotherelement"/>
</xs:choice>
</xs:group>
<xs:attributeGroup name="myelement.attlist">
<xs:attribute name="myattribute" type="xs:string"/>
</xs:attributeGroup>
<xs:complexType name="myelement.type" mixed="true">
<xs:choice>
<xs:group ref="myelement.content" minOccurs="0" maxOccurs="1"/>
</xs:choice>
<xs:attributeGroup ref="myelement.attlist"/>
</xs:complexType>
<xs:element name="myelement" type="myelement.type"/>
The element "myelement" is declared in the target namespace of the schema document and "xs" is the prefix for XML Schema Namespace. After the elements are defined, they need to be integrated into
the content model. Strategies for integrating new elements or sets of elements into the content model are addressed in the next section.
B.3. Defining the content model for a collection of modules
Since the content model of XHTML modules is fully parameterized using named content models, Schema authors may modify the content model for every element in every module. The details of the schema
module interface are defined in Building Schema Modules. Basically there are two ways to approach this modification:
- Re-define the named content model,
.content, for each element.
- Define one or more of the global named content model entities to include the element in those named model definitions (normally via the named content model,
.extras).
The strategy taken will depend upon the nature of the modules being combined and the nature of the elements being integrated. The remainder of this section describes techniques for integrating two
different classes of modules.
B.3.1. Integrating a stand-alone module into XHTML
When a module (and remember, a module can be a collection of other modules) contains elements that only reference each other in their content model, it is said to be "internally complete". As
such, the module can be used on its own; (for example, you could define a schema that was just that module, and use one of its elements as the root element). Integrating such a module into XHTML is a
three step process:
- Decide what element(s) can be thought of as the root(s) of the new module.
- Decide where these elements need to attach in the XHTML content tree.
- Then, for each attachment point in the content tree, add the root element(s) to the content definition for the XHTML elements.
Consider attaching the elements defined above. In that example, the element myelement is the root. To attach this element under the img element, and
only the img element, of XHTML, the following redefinition would work:
<xs:redefine schemaLocation="xhtml-image-1.xsd">
<xs:group name="img.content">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="myml:myelement"/>
</xs:choice>
</xs:group>
</xs:redefine>
Such redefinition must not included in the module definitions, but instead provided as part of the markup model definition. A schema defined with this content model would allow a document like the
following fragment:
<img src="...">
<myml:myelement >This is content of a locally defined element</myml:myelement>
</img>
It is important to note that normally the img element has a content model of EMPTY. By adding myelement to that content model, we are really just replacing
EMPTY with myelement. In the case of other elements that already have content models defined, the addition of an element would require the restating of the existing content model
in addition to myelement.
B.3.2. Mixing a new module throughout the modules in XHTML
Extending the example above, to attach this module everywhere that the %Flow.mix content model group is permitted, would require something like the following in the schema that defines
the document model of the document type:
<xs:redefine schemaLocation="xhtml11-model.xsd">
<xs:group name="Misc.extra">
<xs:choice>
<xs:group ref="Misc.extra"/>
<xs:element ref="xhtml:myelement"/>
</xs:choice>
</xs:group>
</xs:redefine>
Since the %Misc.extra content model class is used in the content model the named model Misc.class, and that named model is used throughout the XHTML modules, the new module would become available
throughout an extended XHTML document type.
B.4. Creating a new Document Type
So far the examples in this section have described the methods of extending XHTML and XHTML's content model. Once this is done, the next step is to collect the modules that comprise the Document
Type into a schema driver and schema file that provides the content model redefinitions of included modules, incorporating the new definitions so that they override and augment the basic XHTML
definitions as appropriate.
B.4.1. Creating a simple Docoment Type
Using the trivial example above, it is possible to define a new schema that uses and extends the XHTML modules pretty easily. First, define the new elements and their content model in a
module:
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.example.com/xmlns/simpleml1"
xmlns="http://www.example.com/xmlns/simpleml1">
<xs:annotation>
<xs:documentation>
This is the XML Schema module for module SimpleML
$Id: simpleml-module-1.xsd,v 1.3 2003/09/23 21:13:11 speruvem Exp $
</xs:documentation>
<xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:attributeGroup name="Common.attrib">
<xs:attribute name="id" type="xs:ID"/>
</xs:attributeGroup>
<xs:group name="otherelement.content">
<xs:sequence/>
</xs:group>
<xs:attributeGroup name="otherelement.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:complexType name="otherelement.type">
<xs:group ref="otherelement.content"/>
<xs:attributeGroup ref="otherelement.attlist"/>
</xs:complexType>
<xs:element name="otherelement" type="otherelement.type"/>
<xs:group name="element.content">
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="otherelement"/>
</xs:choice>
</xs:group>
<xs:attributeGroup name="element.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:complexType name="element.type">
<xs:group ref="element.content"/>
<xs:attributeGroup ref="element.attlist"/>
</xs:complexType>
<xs:element name="element" type="element.type"/>
<!-- Note: Global attribute -->
<xs:attribute name="myattr" type="xs:string"/>
</xs:schema>
Now, define the schema module that redefines the content model of modules included in XHTML Basic 1.0
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:simpleml="http://www.example.com/xmlns/simpleml1">
<xs:annotation>
<xs:documentation>
This is the XML Schema that redefines the
individual XHTML modules (image module) and
redefines a named content model of XHTML modularization
$Id: simpleml-module-redefines-1.xsd,v 1.2 2003/09/23 21:13:11 speruvem Exp $
</xs:documentation>
<xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-basic10-model-1.xsd">
<xs:group name="Misc.class">
<xs:choice>
<xs:group ref="Misc.class"/>
<xs:element ref="simpleml:element"/>
</xs:choice>
</xs:group>
</xs:redefine>
<xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-image-1.xsd">
<xs:attributeGroup name="img.attlist">
<xs:attributeGroup ref="img.attlist"/>
<xs:attribute ref="simpleml:myattr"/>
</xs:attributeGroup>
</xs:redefine>
</xs:schema>
Now, define the schema driver for the new language:
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.example.com/xmlns/simpleml1"
xmlns:xhtml="http://www.w3.org/1999/xhtml"
xmlns="http://www.example.com/xmlns/simpleml1"
blockDefault="#all">
<xs:annotation>
<xs:documentation>
This is the XML Schema Driver for new
Document Type XHTML Basic 1.0 + SimpleML
$Id: simpleml-1_0.xsd,v 1.4 2003/09/23 21:13:11 speruvem Exp $
</xs:documentation>
<xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:include schemaLocation="simpleml-module-1.xsd"/>
<xs:import namespace="http://www.w3.org/1999/xhtml"
schemaLocation="simpleml-module-redefines-1.xsd"/>
<xs:import namespace="http://www.w3.org/1999/xhtml"
schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-basic10.xsd"/>
</xs:schema>
B.4.2. Creating a Language by extending XHTML
Next, there is the situation where a complete, additional, and complex module is added to XHTML (or to a subset of XHTML). In essence, this is the same as in the example above, the only difference
being that the module being added is incorporated in the schema by reference rather than explicitly including the new definitions in the Schema.
One such complex module is the Schema for [MATHML]. In order to combine MathML and XHTML into a single Schema, an author would just decide where MathML
content should be legal in the document, and add the MathML root element to the content model at that point. First, define a new document model that instantiates the MathML Schema and connects it to
the content XHTML content model by redefining the XHTML content model. Providing a redefintion of the XHTML content model by implication includes the XHTML content model in the new document content
model :
<!-- File: math-model.xsd -->
<xs:import namespace="http://www.w3.org/1998/Math/MathML"
schemaLocation="http://www.w3.org/Math/XMLSchema/mathml2/mathml2.xsd"/>
<xs:redefine schemaLocation="xhtml11-model.xsd">
<xs:group name="InlSpecial.class">
<xs:choice>
<xs:group ref="InlSpecial.class"/>
<xs:element ref="math:math"/>
</xs:choice>
</xs:group>
</xs:redefine>
Next, define a Schema driver that includes our new dcoument content model and hands off processing to the XHTML 1.1 driver (for example):
<!-- File: xhtml+mathml.xsd -->
<xs:include schemaLocation="mathml-model.xsd"/>
<xs:include schemaLocation="xhtml11.xsd"/>
B.4.3. Creating a Language by removing and replacing XHTML modules
Another way in which Schema authors may use XHTML modules is to define a Schema that is a subset of an XHTML family document type (because, for example, they are building devices or software that
only supports a subset of XHTML). To do this simple create a Schema driver that does not include the relevant modules. Schema author should note that redefine in schema by default includes
all the content modelof the referenced schema, authors should also not include any redefinitions of modules that they do not wish to include. The basic steps to follow are:
- Take an XHTML family Schema as the basis of the new document type (e.g. XHML 1.1).
- Select the modules to remove from that Schema.
- Physically, remove include elements that include the non relevant modules from the Schema driver file.
- Physically, remove redefine elements that redefine any non relevant modules from module redefinitions file.
- Introduce some new modules
B.4.4. Creating a the new Document Type
Finally, some Schema authors may wish to start from scratch, using the XHTML Modularization framework as a toolkit for building a new markup language. This language must be made up of the minimal,
required modules from XHTML. It may also contain other XHTML-defined modules or any other module that the author wishes to employ. In this example, we will take the XHTML required modules, add some
XHTML-defined modules, and also add in the module we defined above.
The first step is to define a module that defines the elements and attributes using the XHTML provided template.
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.example.com/xmlns/myml"
xmlns="http://www.example.com/xmlns/myml">
<xs:annotation>
<xs:documentation>
This is XML Schema template for MLML module
$Id: myml-module-1.xsd,v 1.2 2003/09/23 21:13:11 speruvem Exp $
</xs:documentation>
<xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
My Elements Module
+ myelement
+ myotherelement
This module has no purpose other than to provide structure for some
PCDATA content.
</xs:documentation>
</xs:annotation>
<xs:attributeGroup name="myotherelement.attlist"/>
<xs:group name="myotherelement.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="myotherelement.type">
<xs:group ref="myotherelement.content"/>
<xs:attributeGroup ref="myotherelement.attlist"/>
</xs:complexType>
<xs:element name="myotherelement" type="myotherelement.type"/>
<xs:group name="myelement.content">
<xs:choice>
<xs:element ref="myotherelement"/>
</xs:choice>
</xs:group>
<xs:attributeGroup name="myelement.attlist">
<xs:attribute name="myattribute" type="xs:string"/>
</xs:attributeGroup>
<xs:complexType name="myelement.type" mixed="true">
<xs:choice>
<xs:group ref="myelement.content" minOccurs="0" maxOccurs="1"/>
</xs:choice>
<xs:attributeGroup ref="myelement.attlist"/>
</xs:complexType>
<xs:element name="myelement" type="myelement.type"/>
<!-- Note: Global attribute -->
<xs:attribute name="myattr" type="xs:string"/>
</xs:schema>
Now, build a content model description that hooks the new elements and attributes into the other XHTML elements. The following example is patterned after the XHTML Basic content model, but is a
complete, free-standing content model module:
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:myml="http://www.example.com/xmlns/myml">
<xs:annotation>
<xs:documentation>
This is the XML Schema module of common content models for MyML
$Id: myml-model-1.xsd,v 1.3 2003/09/23 21:17:44 speruvem Exp $
</xs:documentation>
<xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
XHTML Document Model
This module describes the groupings of elements/attributes that make up
common content models for XHTML elements.
XHTML has following basic content models:
Inline.mix; character-level elements
Block.mix; block-like elements, eg., paragraphs and lists
Flow.mix; any block or inline elements
HeadOpts.mix; Head Elements
InlinePre.mix; Special class for pre content model
InlineNoAnchor.mix; Content model for Anchor
Any groups declared in this module may be used
to create element content models, but the above are
considered 'global' (insofar as that term applies here).
XHTML has the following Attribute Groups
Core.extra.attrib
I18n.extra.attrib
Common.extra
The above attribute Groups are considered Global
</xs:documentation>
</xs:annotation>
<xs:attributeGroup name="I18n.extra.attrib">
<xs:annotation>
<xs:documentation>
Extended I18n attribute
</xs:documentation>
</xs:annotation>
</xs:attributeGroup>
<xs:attributeGroup name="Core.extra.attrib">
<xs:annotation>
<xs:documentation>
Extended Core Attributes
</xs:documentation>
</xs:annotation>
</xs:attributeGroup>
<xs:attributeGroup name="Common.extra">
<xs:annotation>
<xs:documentation>
Extended Common Attributes
</xs:documentation>
</xs:annotation>
</xs:attributeGroup>
<xs:group name="HeadOpts.mix">
<xs:choice>
<xs:element ref="meta"/>
<xs:element ref="link"/>
<xs:element ref="object"/>
</xs:choice>
</xs:group>
<!--
These elements are neither block nor inline, and can
essentially be used anywhere in the document body.
-->
<xs:group name="Misc.class">
<xs:choice>
<xs:element ref="myml:myelement"/>
</xs:choice>
</xs:group>
<!-- Inline Elements -->
<xs:group name="InlStruct.class">
<xs:choice>
<xs:element ref="br"/>
<xs:element ref="span"/>
</xs:choice>
</xs:group>
<xs:group name="InlPhras.class">
<xs:choice>
<xs:element ref="em"/>
<xs:element ref="strong"/>
<xs:element ref="dfn"/>
<xs:element ref="code"/>
<xs:element ref="samp"/>
<xs:element ref="kbd"/>
<xs:element ref="var"/>
<xs:element ref="cite"/>
<xs:element ref="abbr"/>
<xs:element ref="acronym"/>
<xs:element ref="q"/>
</xs:choice>
</xs:group>
<xs:group name="InlPres.class">
<xs:choice/>
</xs:group>
<xs:group name="I18n.class">
<xs:sequence/>
</xs:group>
<xs:group name="Anchor.class">
<xs:sequence>
<xs:element ref="a"/>
</xs:sequence>
</xs:group>
<xs:group name="InlSpecial.class">
<xs:choice>
<xs:element ref="img"/>
<xs:element ref="object"/>
</xs:choice>
</xs:group>
<xs:group name="InlForm.class">
<xs:choice>
<xs:element ref="input"/>
<xs:element ref="select"/>
<xs:element ref="textarea"/>
<xs:element ref="label"/>
</xs:choice>
</xs:group>
<xs:group name="Inline.extra">
<xs:choice/>
</xs:group>
<!--xs:group name="Ruby.class">
<xs:sequence/>
</xs:group-->
<!--
Inline.class includes all inline elements,
used as a component in mixes
-->
<xs:group name="Inline.class">
<xs:choice>
<xs:group ref="InlStruct.class"/>
<xs:group ref="InlPhras.class"/>
<xs:group ref="Anchor.class"/>
<xs:group ref="InlSpecial.class"/>
<xs:group ref="InlForm.class"/>
<xs:group ref="Inline.extra"/>
</xs:choice>
</xs:group>
<!--
InlinePre.class
Used as a component in pre model
-->
<xs:group name="InlinePre.mix">
<xs:choice>
<xs:group ref="InlStruct.class"/>
<xs:group ref="InlPhras.class"/>
<xs:group ref="Anchor.class"/>
<xs:group ref="Inline.extra"/>
</xs:choice>
</xs:group>
<!--
InlNoAnchor.class includes all non-anchor inlines,
used as a component in mixes
-->
<xs:group name="InlNoAnchor.class">
<xs:choice>
<xs:group ref="InlStruct.class"/>
<xs:group ref="InlPhras.class"/>
<xs:group ref="InlSpecial.class"/>
<xs:group ref="InlForm.class"/>
<xs:group ref="Inline.extra"/>
</xs:choice>
</xs:group>
<!--
InlNoAnchor.mix includes all non-anchor inlines
-->
<xs:group name="InlNoAnchor.mix">
<xs:choice>
<xs:group ref="InlNoAnchor.class"/>
<xs:group ref="Misc.class"/>
</xs:choice>
</xs:group>
<!--
Inline.mix includes all inline elements, including Misc.class
-->
<xs:group name="Inline.mix">
<xs:choice>
<xs:group ref="Inline.class"/>
<xs:group ref="Misc.class"/>
</xs:choice>
</xs:group>
<!--
In the HTML 4 DTD, heading and list elements were included
in the block group. The Heading.class and
List.class groups must now be included explicitly
on element declarations where desired.
-->
<xs:group name="Heading.class">
<xs:choice>
<xs:element ref="h1"/>
<xs:element ref="h2"/>
<xs:element ref="h3"/>
<xs:element ref="h4"/>
<xs:element ref="h5"/>
<xs:element ref="h6"/>
</xs:choice>
</xs:group>
<xs:group name="List.class">
<xs:choice>
<xs:element ref="ul"/>
<xs:element ref="ol"/>
<xs:element ref="dl"/>
</xs:choice>
</xs:group>
<xs:group name="Table.class">
<xs:choice>
<xs:element ref="table"/>
</xs:choice>
</xs:group>
<xs:group name="Form.class">
<xs:choice>
<xs:element ref="form"/>
</xs:choice>
</xs:group>
<xs:group name="BlkStruct.class">
<xs:choice>
<xs:element ref="p"/>
<xs:element ref="div"/>
</xs:choice>
</xs:group>
<xs:group name="BlkPhras.class">
<xs:choice>
<xs:element ref="pre"/>
<xs:element ref="blockquote"/>
<xs:element ref="address"/>
</xs:choice>
</xs:group>
<xs:group name="BlkPres.class">
<xs:choice/>
</xs:group>
<xs:group name="BlkSpecial.class">
<xs:choice>
<xs:group ref="Table.class"/>
<xs:group ref="Form.class"/>
</xs:choice>
</xs:group>
<xs:group name="Block.extra">
<xs:choice/>
</xs:group>
<!--
Block.class includes all block elements,
used as an component in mixes
-->
<xs:group name="Block.class">
<xs:choice>
<xs:group ref="BlkStruct.class"/>
<xs:group ref="BlkPhras.class"/>
<xs:group ref="BlkSpecial.class"/>
<xs:group ref="Block.extra"/>
</xs:choice>
</xs:group>
<!--
Block.mix includes all block elements plus %Misc.class;
-->
<xs:group name="Block.mix">
<xs:choice>
<xs:group ref="Heading.class"/>
<xs:group ref="List.class"/>
<xs:group ref="Block.class"/>
<xs:group ref="Misc.class"/>
</xs:choice>
</xs:group>
<!--
All Content Elements
Flow.mix includes all text content, block and inline
Note that the "any" element included here allows us
to add data from any other namespace, a necessity
for compound document creation.
Note however that it is not possible to add
to any head level element without further
modification. To add RDF metadata to the head
of a document, modify the structure module.
-->
<xs:group name="Flow.mix">
<xs:choice>
<xs:group ref="Heading.class"/>
<xs:group ref="List.class"/>
<xs:group ref="Block.class"/>
<xs:group ref="Inline.class"/>
<xs:group ref="Misc.class"/>
</xs:choice>
</xs:group>
<xs:group name="FlowNoTable.mix">
<xs:choice>
<xs:group ref="Heading.class"/>
<xs:group ref="List.class"/>
<xs:group ref="BlkStruct.class"/>
<xs:group ref="BlkPhras.class"/>
<xs:group ref="Form.class"/>
<xs:group ref="Inline.class"/>
<xs:group ref="Misc.class"/>
</xs:choice>
</xs:group>
<!--
BlkNoForm.mix includes all non-form block elements,
plus Misc.class
-->
<xs:group name="BlkNoForm.mix">
<xs:choice>
<xs:group ref="Heading.class"/>
<xs:group ref="List.class"/>
<xs:group ref="BlkStruct.class"/>
<xs:group ref="BlkPhras.class"/>
<xs:group ref="BlkPres.class"/>
<xs:group ref="Table.class"/>
<xs:group ref="Misc.class"/>
</xs:choice>
</xs:group>
</xs:schema>
Now, build a list of redefinitions that change the content model of various included modules. The following example is patterned after the redefinitions in XHTML Basic document type and modified
as appropriate for our new markup language:
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:myml="http://www.example.com/xmlns/myml">
<xs:annotation>
<xs:documentation>
This is the XML Schema changes to the content models
of modules included in XHTML Basic 1.0 + MyML
$Id: myml-module-redefines-1.xsd,v 1.2 2003/09/23 21:13:11 speruvem Exp $
</xs:documentation>
<xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Module Content Model Redefinitions
This schema describes the changes (Redefinitions) to
content model of individual modules as they are instantiated as part of
XHTML Basic 1.0 + MyML document
</xs:documentation>
</xs:annotation>
<!-- Changes to Structural Module -->
<xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-struct-1.xsd">
<xs:group name="head.content">
<xs:annotation>
<xs:documentation>
Redefinition by Base module
</xs:documentation>
</xs:annotation>
<xs:sequence>
<xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
<xs:choice>
<xs:sequence>
<xs:element ref="title"/>
<xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
<xs:element ref="base" minOccurs="0"/>
</xs:sequence>
<xs:sequence>
<xs:element ref="base"/>
<xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
<xs:element ref="title"/>
</xs:sequence>
</xs:choice>
<xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:attributeGroup name="version.attrib">
<xs:annotation>
<xs:documentation>
Redefinition by the XHTML11 Markup (for value of version attr)
</xs:documentation>
</xs:annotation>
<xs:attribute name="version" type="FPI" fixed="-//W3C//DTD XHTML Basic 1.0 + MyML//EN"/>
</xs:attributeGroup>
</xs:redefine>
<xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-image-1.xsd">
<xs:attributeGroup name="img.attlist">
<xs:attributeGroup ref="img.attlist"/>
<xs:attribute ref="myml:myattr"/>
</xs:attributeGroup>
</xs:redefine>
</xs:schema>
Finally, build a driver for a new SCHEMA. The following example is patterned after the XHTML Basic content model and modified as appropriate for our new markup language:
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:myml="http://www.example.com/xmlns/myml"
blockDefault="#all">
<xs:annotation>
<xs:documentation>
This is the XML Schema driver for XHTML Basic 1.0.
Please use this namespace for XHTML elements:
"http://www.w3.org/1999/xhtml"
$Id: myml-1_0.xsd,v 1.3 2003/09/23 21:13:11 speruvem Exp $
</xs:documentation>
</xs:annotation>
<xs:annotation>
<xs:documentation>
This is XHTML, a reformulation of HTML as a modular XML application
The Extensible HyperText Markup Language (XHTML)
Copyright ©1998-2003 World Wide Web Consortium
(Massachusetts Institute of Technology, Institut National de
Recherche en Informatique et en Automatique, Keio University).
All Rights Reserved.
Permission to use, copy, modify and distribute the XHTML Schema
modules and their accompanying xs:documentation for any purpose
and without fee is hereby granted in perpetuity, provided that the above
copyright notice and this paragraph appear in all copies.
The copyright holders make no representation about the suitability of
these XML Schema modules for any purpose.
They are provided "as is" without expressed or implied warranty.
</xs:documentation>
</xs:annotation>
<xs:annotation>
<xs:documentation>
This is the Schema Driver file for
XHTML Basic 1.0 + MyML Document Type
This schema includes
+ modules for XHTML Basic 1.0 Document Type.
+ module MyML (MyML Namespace)
+ schema that defines all the named model for
the XHTML Basic 1.0 + MyML Document Type
+ schema that redefines the content model of
individual elements defined in the Module
implementations.
This Document Type includes the following Modules
XHTML Core modules (Required for XHTML Family Conformance)
+ text
+ hypertext
+ lists
+ structure
Other XHTML modules
+ Link
+ Meta
+ Base
+ Image
+ Object
+ Param
+ Basic forms
+ Basic tables
Other Modules
+ MyML Module
</xs:documentation>
</xs:annotation>
<xs:include schemaLocation="myml-module-redefines-1.xsd">
<xs:annotation>
<xs:documentation>
This schema redefines the content model
defined by the individual modules for
XHTML Basic 1.0Document Type
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="myml-model-1.xsd">
<xs:annotation>
<xs:documentation>
Document Model module for the XHTML Basic 1.0 Document Type
This schema file defines all named models used by XHTML
Modularization Framework for XHTML Basic 1.0 Document Type
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-framework-1.xsd">
<xs:annotation>
<xs:documentation>
Schema Framework Component Modules:
+ notations
+ datatypes
+ common attributes
+ character entities
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/xhtml-modularization/abstract_modules.html#s_commonatts"/>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-text-1.xsd">
<xs:annotation>
<xs:documentation>
Text module
The Text module includes declarations for all core
text container elements and their attributes.
+ block phrasal
+ block structural
+ inline phrasal
+ inline structural
Elements defined here:
* address, blockquote, pre, h1, h2, h3, h4, h5, h6
* div, p
* abbr, acronym, cite, code, dfn, em, kbd, q, samp, strong, var
* br, span
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_textmodule"/>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-hypertext-1.xsd">
<xs:annotation>
<xs:documentation>
Hypertext module
Elements defined here:
* a
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_hypertextmodule"/>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-list-1.xsd">
<xs:annotation>
<xs:documentation>
Lists module
Elements defined here:
* dt, dd, dl, ol, ul, li
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_listmodule"/>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-struct-1.xsd">
<xs:annotation>
<xs:documentation>
Structural module
Elements defined here:
* title, head, body, html
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_structuremodule"/>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-link-1.xsd">
<xs:annotation>
<xs:documentation>
Link module
Elements defined here:
* link
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-meta-1.xsd">
<xs:annotation>
<xs:documentation>
Meta module
Elements defined here:
* meta
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-base-1.xsd">
<xs:annotation>
<xs:documentation>
Base module
Elements defined here:
* base
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-image-1.xsd">
<xs:annotation>
<xs:documentation>
Image module
Elements defined here:
* img
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-object-1.xsd">
<xs:annotation>
<xs:documentation>
Object module
Elements defined here:
* object
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-param-1.xsd">
<xs:annotation>
<xs:documentation>
Param module
Elements defined here:
* param
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-basic-form-1.xsd">
<xs:annotation>
<xs:documentation>
Basic Forms module
Note that this module is not used in XHTML 1.1. It is designed
for use with XHTML Basic
Elements defined here:
* form, label, input, select, option, textarea
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-basic-table-1.xsd">
<xs:annotation>
<xs:documentation>
Basic Tables module
Note that this module is not used in XHTML It is designed
for use with XHTML Basic
Elements defined here:
* table, caption, tr, th, td
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:import namespace="http://www.example.com/xmlns/myml"
schemaLocation="myml-module-1.xsd">
<xs:annotation>
<xs:documentation>
MyML Module
Elements defined here:
* myelement, myotherelement
</xs:documentation>
</xs:annotation>
</xs:import>
</xs:schema>
Once a new SCHEMA has been developed, it can be used in any document. Using the Schema is as simple as just referencing it in the schemaLocation attribute of a document root element:
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:myml="http://www.example.com/xmlns/myml"
xmlns:schemaLocation="http://www.w3.org/1999/xhtml myml-1_0.xsd">
<head>
<title>An example using defaults</title>
</head>
<body>
<p>This is content in the XHTML namespace</p>
<myml:myelement>
This is content in the myml namespace.
<myml:myotherelement />
</myml:myelement>
<p><img src="missing" alt="Missing image" myml:myattr="value" /></p>
</body>
</html>
C. XHTML Schema Module Implementations
This appendix is normative.
This appendix will contain implementations of the modules defined in XHTML Abstract Modules via XML Schemas. These module implementations can be used by XHTML Family Document Types.
C.1. Character Entities
XML Schema uses DTDs to support character entities. The DTD implementation of XHTML Modularization [XHTMLMOD] defines the required character entities for XHTML. The schema implementation includes
the set of character entities for XHTML, including the Latin 1, Symbol and Special character collections defined as part the DTD implementation of XHTML Modularization [XHTMLMOD].
Even though the named character entities are defined using DTDs and included in the Schema Modularization Framework, schema processors typically do not expand the named character
entities in an XML document instance. The html DOCTYPE declaration must still be present if one wishes to use named entities defined by this Framework module
C.2. XHTML Schema Modular Framework
The Framework modules instantiates a set of support model that define the common Datatypes, Notations, Common attribute definitions and character entities. These are are defined in a set of
support modules, instantiated by a main Framework module:
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
XHTML Modular Framework
This is the XML Schema Modular Framework module for XHTML
This required module instantiates the necessary modules
needed to support the XHTML modularization framework.
The Schema modules instantiated are:
+ notations
+ datatypes
+ common attributes
+ character entities
$Id: xhtml-framework-1.xsd,v 1.8 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:import namespace="http://www.w3.org/XML/1998/namespace"
schemaLocation="http://www.w3.org/2001/xml.xsd">
<xs:annotation>
<xs:documentation>
Common Attributes
This import brings in the attributes
xml:lang and xml:space in the XML namespace.
</xs:documentation>
</xs:annotation>
</xs:import>
<xs:include schemaLocation="xhtml-notations-1.xsd">
<xs:annotation>
<xs:documentation>
Notations module
Declares XHTML notations for Attribute data types
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="xhtml-datatypes-1.xsd">
<xs:annotation>
<xs:documentation>
This module defines XHTML Attribute DataTypes
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstraction.html#s_common_attrtypes"/>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="xhtml-attribs-1.xsd">
<xs:annotation>
<xs:documentation>
This module defines Common attributes for XHTML
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_commonatts"/>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="xhtml-charent-1.xsd">
<xs:annotation>
<xs:documentation>
Character entities module
Note: Entities are not supported in XML Schema
The Schema Module uses DTDs to define Entities
This module defines
+ XHTML Latin 1 Character Entities
+ XHTML Special Characters
+ XHTML Mathematical, Greek, and Symbolic Characters
</xs:documentation>
</xs:annotation>
</xs:include>
</xs:schema>
The Modular Schema framework also relies upon the following component modules:
C.2.1. XHTML Notations
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Notations module
This is the XML Schema module for data type notations for XHTML
Defines the following notations, many of these imported from
other specifications and standards. When an existing FPI is
known, it is incorporated here.
$Id: xhtml-notations-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<!-- W3C XML 1.0 Recommendation -->
<xs:notation name="w3c-xml"
public="ISO 8879//NOTATION Extensible Markup Language (XML) 1.0//EN"/>
<!-- XML 1.0 CDATA -->
<xs:notation name="cdata" public="-//W3C//NOTATION XML 1.0: CDATA//EN"/>
<!-- SGML Formal Public Identifiers -->
<xs:notation name="fpi"
public="ISO 8879:1986//NOTATION Formal Public Identifier//EN"/>
<!-- XHTML Notations ... -->
<!-- Length defined for cellpadding/cellspacing -->
<!-- nn for pixels or nn% for percentage length -->
<!-- a single character, as per section 2.2 of [XML] -->
<xs:notation name="character"
public="-//W3C//NOTATION XHTML Datatype: Character//EN"/>
<!-- a character encoding, as per [RFC2045] -->
<xs:notation name="charset"
public="-//W3C//NOTATION XHTML Datatype: Charset//EN"/>
<!-- a space separated list of character encodings, as per [RFC2045] -->
<xs:notation name="charsets"
public="-//W3C//NOTATION XHTML Datatype: Charsets//EN"/>
<!-- media type, as per [RFC2045] -->
<xs:notation name="contentType"
public="-//W3C//NOTATION XHTML Datatype: ContentType//EN"/>
<!-- comma-separated list of media types, as per [RFC2045] -->
<xs:notation name="contentTypes"
public="-//W3C//NOTATION XHTML Datatype: ContentTypes//EN"/>
<!-- date and time information. ISO date format -->
<xs:notation name="datetime"
public="-//W3C//NOTATION XHTML Datatype: Datetime//EN"/>
<!-- a language code, as per [RFC3066] -->
<xs:notation name="languageCode"
public="-//W3C//NOTATION XHTML Datatype: LanguageCode//EN"/>
<!-- nn for pixels or nn% for percentage length -->
<xs:notation name="length"
public="-//W3C//NOTATION XHTML Datatype: Length//EN"/>
<!-- space-separated list of link types -->
<xs:notation name="linkTypes"
public="-//W3C//NOTATION XHTML Datatype: LinkTypes//EN"/>
<!-- single or comma-separated list of media descriptors -->
<xs:notation name="mediaDesc"
public="-//W3C//NOTATION XHTML Datatype: MediaDesc//EN"/>
<!-- pixel, percentage, or relative -->
<xs:notation name="multiLength"
public="-//W3C//NOTATION XHTML Datatype: MultiLength//EN"/>
<!-- one or more digits (NUMBER) -->
<xs:notation name="number"
public="-//W3C//NOTATION XHTML Datatype: Number//EN"/>
<!-- one or more digits (NUMBER) -->
<xs:notation name="pixels"
public="-//W3C//NOTATION XHTML Datatype: Pixels//EN"/>
<!-- script expression -->
<xs:notation name="script"
public="-//W3C//NOTATION XHTML Datatype: Script//EN"/>
<!-- textual content -->
<xs:notation name="text" public="-//W3C//NOTATION XHTML Datatype: Text//EN"/>
<!-- a Uniform Resource Identifier, see [URI] -->
<xs:notation name="uri" public="-//W3C//NOTATION XHTML Datatype: URI//EN"/>
<!-- a space-separated list of Uniform Resource Identifiers, see [URI] -->
<xs:notation name="uris" public="-//W3C//NOTATION XHTML Datatype: URIs//EN"/>
</xs:schema>
C.2.2. XHTML Datatypes
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
XHTML Datatypes
This is the XML Schema datatypes module for XHTML
Defines containers for the XHTML datatypes, many of
these imported from other specifications and standards.
$Id: xhtml-datatypes-1.xsd,v 1.3 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstraction.html#s_common_attrtypes"/>
</xs:annotation>
<!-- nn for pixels or nn% for percentage length -->
<xs:simpleType name="Length">
<xs:union memberTypes="xs:nonNegativeInteger">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:pattern value="\d+[%]|\d*\.\d+[%]"/>
</xs:restriction>
</xs:simpleType>
</xs:union>
</xs:simpleType>
<!-- space-separated list of link types -->
<xs:simpleType name="LinkTypes">
<xs:list itemType="xs:NMTOKEN"/>
</xs:simpleType>
<!-- single or comma-separated list of media descriptors -->
<xs:simpleType name="MediaDesc">
<xs:restriction base="xs:string"/>
</xs:simpleType>
<!-- pixel, percentage, or relative -->
<xs:simpleType name="MultiLength">
<xs:union memberTypes="Length">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:pattern value="\d*\*"/>
</xs:restriction>
</xs:simpleType>
</xs:union>
</xs:simpleType>
<!-- one or more digits (NUMBER) -->
<xs:simpleType name="Number">
<xs:restriction base="xs:nonNegativeInteger"/>
</xs:simpleType>
<!-- integer representing length in pixels -->
<xs:simpleType name="Pixels">
<xs:restriction base="xs:nonNegativeInteger"/>
</xs:simpleType>
<!-- script expression -->
<xs:simpleType name="Script">
<xs:restriction base="xs:string"/>
</xs:simpleType>
<!-- sixteen color names or RGB color expression-->
<xs:simpleType name="Color">
<xs:union memberTypes="xs:NMTOKEN">
<xs:simpleType>
<xs:restriction base="xs:token">
<xs:pattern value="#[0-9a-fA-F]{6}"/>
</xs:restriction>
</xs:simpleType>
</xs:union>
</xs:simpleType>
<!-- textual content -->
<xs:simpleType name="Text">
<xs:restriction base="xs:string"/>
</xs:simpleType>
<!-- Imported Datatypes -->
<!-- a single character, as per section 2.2 of [XML] -->
<xs:simpleType name="Character">
<xs:restriction base="xs:string">
<xs:length value="1" fixed="true"/>
</xs:restriction>
</xs:simpleType>
<!-- a character encoding, as per [RFC2045] -->
<xs:simpleType name="Charset">
<xs:restriction base="xs:string"/>
</xs:simpleType>
<!-- a space separated list of character encodings, as per [RFC2045] -->
<xs:simpleType name="Charsets">
<xs:list itemType="Charset"/>
</xs:simpleType>
<!-- media type, as per [RFC2045] -->
<xs:simpleType name="ContentType">
<xs:list itemType="xs:string"/>
</xs:simpleType>
<!-- comma-separated list of media types, as per [RFC2045] -->
<xs:simpleType name="ContentTypes">
<xs:list itemType="xs:string"/>
</xs:simpleType>
<!-- date and time information. ISO date format -->
<xs:simpleType name="Datetime">
<xs:restriction base="xs:dateTime"/>
</xs:simpleType>
<!-- formal public identifier, as per [ISO8879] -->
<xs:simpleType name="FPI">
<xs:restriction base="xs:normalizedString"/>
</xs:simpleType>
<!-- a language code, as per [RFC3066] -->
<xs:simpleType name="LanguageCode">
<xs:restriction base="xs:language"/>
</xs:simpleType>
<!-- a Uniform Resource Identifier, see [URI] -->
<xs:simpleType name="URI">
<xs:restriction base="xs:anyURI"/>
</xs:simpleType>
<!-- a space-separated list of Uniform Resource Identifiers, see [URI] -->
<xs:simpleType name="URIs">
<xs:list itemType="xs:anyURI"/>
</xs:simpleType>
<!-- comma-separated list of MultiLength -->
<xs:simpleType name="MultiLengths">
<xs:restriction base="xs:string"/>
</xs:simpleType>
<!-- character Data -->
<xs:simpleType name="CDATA">
<xs:restriction base="xs:string"/>
</xs:simpleType>
</xs:schema>
C.2.3. XHTML Common Attribute Definitions
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xml="http://www.w3.org/XML/1998/namespace"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema common attributes module for XHTML
$Id: xhtml-attribs-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:attributeGroup name="id">
<xs:attribute name="id" type="xs:ID"/>
</xs:attributeGroup>
<xs:attributeGroup name="class">
<xs:attribute name="class" type="xs:NMTOKENS"/>
</xs:attributeGroup>
<xs:attributeGroup name="title">
<xs:attribute name="title" type="xs:string"/>
</xs:attributeGroup>
<xs:attributeGroup name="Core.attrib">
<xs:attributeGroup ref="id"/>
<xs:attributeGroup ref="class"/>
<xs:attributeGroup ref="title"/>
<xs:attributeGroup ref="Core.extra.attrib"/>
</xs:attributeGroup>
<xs:attributeGroup name="I18n.attrib">
<xs:attribute ref="xml:lang"/>
<xs:attributeGroup ref="I18n.extra.attrib"/>
</xs:attributeGroup>
<xs:attributeGroup name="Common.attrib">
<xs:attributeGroup ref="Core.attrib"/>
<xs:attributeGroup ref="I18n.attrib"/>
<xs:attributeGroup ref="Common.extra"/>
</xs:attributeGroup>
</xs:schema>
C.2.4. XHTML Character Entities
<?xml version="1.0" encoding="UTF-8"?>
<!--
This schema module includes three named character entity files.
-->
<!DOCTYPE xs:schema [
<!-- These are the entity sets for ISO Latin 1 characters for the XHTML -->
<!ENTITY % HTMLlat1 PUBLIC
"-//W3C//ENTITIES Latin 1 for XHTML//EN"
"http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-lat1.ent">
%HTMLlat1;
<!-- These are the entity sets for special characters for the XHTML -->
<!ENTITY % HTMLsymbol PUBLIC
"-//W3C//ENTITIES Symbols for XHTML//EN"
"http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-symbol.ent">
%HTMLsymbol;
<!-- These are the entity sets for symbol characters for the XHTML -->
<!ENTITY % HTMLspecial PUBLIC
"-//W3C//ENTITIES Special for XHTML//EN"
"http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-special.ent">
%HTMLspecial;
]>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Character Entities for XHTML
This is the XML Schema Character Entities module for XHTML
This module declares the set of character entities for XHTML,
including the Latin 1, Symbol and Special character collections.
XML Schema does not support Entities, hence Entities are enable
through an Internal DTD Subset.
$Id: xhtml-charent-1.xsd,v 1.3 2003/09/23 21:32:35 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
</xs:schema>
C.3. XHTML Module Implementations
This section contains the formal definition of each of the XHTML Abstract Modules as a Schema module.
C.3.1. XHTML Core Modules
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema" >
<xs:annotation>
<xs:documentation>
This is the XML Schema Document Structure module for XHTML
Document Structure
* title, head, body, html
The Structure Module defines the major structural elements and
their attributes.
$Id: xhtml-struct-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_structuremodule"/>
</xs:annotation>
<xs:attributeGroup name="title.attlist">
<xs:attributeGroup ref="I18n.attrib"/>
</xs:attributeGroup>
<xs:group name="title.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="title.type" mixed="true">
<xs:group ref="title.content"/>
<xs:attributeGroup ref="title.attlist"/>
</xs:complexType>
<xs:element name="title" type="title.type"/>
<xs:group name="head.content">
<xs:sequence>
<xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
<xs:element ref="title"/>
<xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:attributeGroup name="profile.attrib">
<xs:attribute name="profile" type="URI"/>
</xs:attributeGroup>
<xs:attributeGroup name="head.attlist">
<xs:attributeGroup ref="profile.attrib"/>
<xs:attributeGroup ref="I18n.attrib"/>
</xs:attributeGroup>
<xs:complexType name="head.type">
<xs:group ref="head.content"/>
<xs:attributeGroup ref="head.attlist"/>
</xs:complexType>
<xs:element name="head" type="head.type"/>
<xs:attributeGroup name="body.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="body.content">
<xs:sequence>
<xs:group ref="Block.mix" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="body.type">
<xs:group ref="body.content"/>
<xs:attributeGroup ref="body.attlist"/>
</xs:complexType>
<xs:element name="body" type="body.type"/>
<xs:attributeGroup name="version.attrib">
<xs:attribute name="version" type="FPI"/>
</xs:attributeGroup>
<xs:attributeGroup name="html.attlist">
<xs:attributeGroup ref="version.attrib"/>
<xs:attributeGroup ref="I18n.attrib"/>
</xs:attributeGroup>
<xs:group name="html.content">
<xs:sequence>
<xs:element ref="head"/>
<xs:element ref="body"/>
</xs:sequence>
</xs:group>
<xs:complexType name="html.type">
<xs:group ref="html.content"/>
<xs:attributeGroup ref="html.attlist"/>
</xs:complexType>
<xs:element name="html" type="html.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Textual Content
This is the XML Schema Text module for XHTML
The Text module includes declarations for all core
text container elements and their attributes.
+ block phrasal
+ block structural
+ inline phrasal
+ inline structural
$Id: xhtml-text-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_textmodule"/>
</xs:annotation>
<xs:include schemaLocation="xhtml-blkphras-1.xsd">
<xs:annotation>
<xs:documentation>
Block Phrasal module
Elements defined here:
* address, blockquote, pre, h1, h2, h3, h4, h5, h6
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="xhtml-blkstruct-1.xsd">
<xs:annotation>
<xs:documentation>
Block Structural module
Elements defined here:
* div, p
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="xhtml-inlphras-1.xsd">
<xs:annotation>
<xs:documentation>
Inline Phrasal module
Elements defined here:
* abbr, acronym, cite, code, dfn, em, kbd, q, samp, strong, var
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="xhtml-inlstruct-1.xsd">
<xs:annotation>
<xs:documentation>
Inline Structural module
Elements defined here:
* br,span
</xs:documentation>
</xs:annotation>
</xs:include>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Hypertext Module
This is the XML Schema Hypertext module for XHTML
* a
This module declares the anchor ('a') element type, which
defines the source of a hypertext link. The destination
(or link 'target') is identified via its 'id' attribute
rather than the 'name' attribute as was used in HTML.
$Id: xhtml-hypertext-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_hypertextmodule"/>
</xs:annotation>
<xs:attributeGroup name="a.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="href" type="URI"/>
<xs:attribute name="charset" type="Charset"/>
<xs:attribute name="type" type="ContentType"/>
<xs:attribute name="hreflang" type="LanguageCode"/>
<xs:attribute name="rel" type="LinkTypes"/>
<xs:attribute name="rev" type="LinkTypes"/>
<xs:attribute name="accesskey" type="Character"/>
<xs:attribute name="tabindex" type="Number"/>
</xs:attributeGroup>
<xs:group name="a.content">
<xs:sequence>
<xs:group ref="InlNoAnchor.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="a.type" mixed="true">
<xs:group ref="a.content"/>
<xs:attributeGroup ref="a.attlist"/>
</xs:complexType>
<xs:element name="a" type="a.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
List Module
This is the XML Schema Lists module for XHTML
List Module Elements
* dl, dt, dd, ol, ul, li
This module declares the list-oriented element types
and their attributes.
$Id: xhtml-list-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_listmodule"/>
</xs:annotation>
<xs:attributeGroup name="dt.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="dt.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="dt.type" mixed="true">
<xs:group ref="dt.content"/>
<xs:attributeGroup ref="dt.attlist"/>
</xs:complexType>
<xs:element name="dt" type="dt.type"/>
<xs:attributeGroup name="dd.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="dd.content">
<xs:sequence>
<xs:group ref="Flow.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="dd.type" mixed="true">
<xs:group ref="dd.content"/>
<xs:attributeGroup ref="dd.attlist"/>
</xs:complexType>
<xs:element name="dd" type="dd.type"/>
<xs:attributeGroup name="dl.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="dl.content">
<xs:sequence>
<xs:choice maxOccurs="unbounded">
<xs:element ref="dt"/>
<xs:element ref="dd"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="dl.type">
<xs:group ref="dl.content"/>
<xs:attributeGroup ref="dl.attlist"/>
</xs:complexType>
<xs:element name="dl" type="dl.type"/>
<xs:attributeGroup name="li.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="li.content">
<xs:sequence>
<xs:group ref="Flow.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="li.type" mixed="true">
<xs:group ref="li.content"/>
<xs:attributeGroup ref="li.attlist"/>
</xs:complexType>
<xs:element name="li" type="li.type"/>
<xs:attributeGroup name="ol.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="ol.content">
<xs:sequence>
<xs:element ref="li" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="ol.type">
<xs:group ref="ol.content"/>
<xs:attributeGroup ref="ol.attlist"/>
</xs:complexType>
<xs:element name="ol" type="ol.type"/>
<xs:attributeGroup name="ul.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="ul.content">
<xs:sequence>
<xs:element ref="li" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="ul.type">
<xs:group ref="ul.content"/>
<xs:attributeGroup ref="ul.attlist"/>
</xs:complexType>
<xs:element name="ul" type="ul.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Java Applets
This is the XML Schema module for Java Applets in XHTML
* applet (param)
This module declares the applet element type and its attributes,
used to provide support for Java applets. The 'alt' attribute
is now required (as it is on images). One of either code or
object attributes must be present. In the document, place param
elements before the object elements that require their content.
Note that use of this module also instantiates of the
Param Element Module.
$Id: xhtml-applet-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_appletmodule"/>
</xs:annotation>
<xs:include schemaLocation="xhtml-param-1.xsd">
<xs:annotation>
<xs:documentation>
Param module
Include Param Module
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:attributeGroup name="applet.attlist">
<xs:attributeGroup ref="Core.attrib"/>
<xs:attribute name="alt" type="Text" use="required"/>
<xs:attribute name="archive" type="CDATA"/>
<xs:attribute name="code" type="CDATA"/>
<xs:attribute name="codebase" type="URI"/>
<xs:attribute name="object" type="CDATA"/>
<xs:attribute name="width" type="Length" use="required"/>
<xs:attribute name="height" type="Length" use="required"/>
</xs:attributeGroup>
<xs:group name="applet.content">
<xs:sequence>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="param" />
<xs:group ref="Flow.mix"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="applet.type" mixed="true">
<xs:group ref="applet.content"/>
<xs:attributeGroup ref="applet.attlist"/>
</xs:complexType>
<xs:element name="applet" type="applet.type"/>
</xs:schema>
C.3.3. Text Modules
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Presentation module for XHTML
This is a REQUIRED module.
$Id: xhtml-pres-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Presentational Elements
This module defines elements and their attributes for
simple presentation-related markup.
Elements defined here:
* hr
* b, big, i, small, sub, sup, tt
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_presentationmodule"/>
</xs:annotation>
<xs:include schemaLocation="xhtml-blkpres-1.xsd">
<xs:annotation>
<xs:documentation>
Block Presentational module
Elements defined here:
* hr
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="xhtml-inlpres-1.xsd">
<xs:annotation>
<xs:documentation>
Inline Presentational module
Elements defined here:
* b, big, i, small, sub, sup, tt
</xs:documentation>
</xs:annotation>
</xs:include>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Editing Elements
This is the XML Schema Editing Markup module for XHTML
* ins, del
This module declares element types and attributes used to indicate
inserted and deleted content while editing a document.
$Id: xhtml-edit-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_editmodule"/>
</xs:annotation>
<xs:attributeGroup name="edit.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="cite" type="URI"/>
<xs:attribute name="datetime" type="Datetime"/>
</xs:attributeGroup>
<xs:group name="edit.content">
<xs:sequence>
<xs:group ref="Flow.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="edit.type" mixed="true">
<xs:group ref="edit.content"/>
<xs:attributeGroup ref="edit.attlist"/>
</xs:complexType>
<!-- ins: Inserted Text -->
<xs:element name="ins" type="edit.type"/>
<!-- del: Deleted Text -->
<xs:element name="del" type="edit.type"/>
</xs:schema>
C.3.3.3. Bi-directional Text
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:xml="http://www.w3.org/XML/1998/namespace">
<xs:annotation>
<xs:documentation>
Bidirectional Override (bdo) Element
This is the XML Schema BDO Element module for XHTML
This modules declares the element 'bdo' and 'dir' attributes,
Used to override the Unicode bidirectional algorithm for selected
fragments of text.
Bidirectional text support includes both the bdo element and
the 'dir' attribute.
$Id: xhtml-bdo-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_bdomodule"/>
</xs:annotation>
<xs:attributeGroup name="bdo.attlist">
<xs:attribute ref="xml:lang"/>
<xs:attributeGroup ref="Core.attrib"/>
<xs:attribute name="dir" use="required">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="ltr"/>
<xs:enumeration value="rtl"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:group name="bdo.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="bdo.type" mixed="true">
<xs:group ref="bdo.content"/>
<xs:attributeGroup ref="bdo.attlist"/>
</xs:complexType>
<xs:element name="bdo" type="bdo.type"/>
<xs:attributeGroup name="dir.attrib">
<xs:attribute name="dir">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="ltr"/>
<xs:enumeration value="rtl"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Basic Forms module for XHTML
$Id: xhtml-basic-form-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Basic Forms
This forms module is based on the HTML 3.2 forms model, with
the WAI-requested addition of the label element. While this
module essentially mimics the content model and attributes of
HTML 3.2 forms, the element types declared herein also include
all HTML 4 common attributes.
Elements defined here:
* form, label, input, select, option, textarea
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_sformsmodule"/>
</xs:annotation>
<xs:attributeGroup name="form.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="action" type="URI" use="required"/>
<xs:attribute name="method" use="optional" default="get">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="get"/>
<xs:enumeration value="post"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="enctype" type="ContentType" default="application/x-www-form-urlencoded"/>
</xs:attributeGroup>
<xs:group name="form.content">
<xs:sequence>
<xs:group ref="BlkNoForm.mix" minOccurs="1" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="form.type">
<xs:group ref="form.content"/>
<xs:attributeGroup ref="form.attlist"/>
</xs:complexType>
<xs:element name="form" type="form.type"/>
<xs:group name="label.content">
<xs:sequence>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="input"/>
<xs:element ref="select"/>
<xs:element ref="textarea"/>
<xs:group ref="InlStruct.class"/>
<xs:group ref="InlPhras.class"/>
<xs:group ref="I18n.class"/>
<xs:group ref="InlPres.class"/>
<xs:group ref="InlSpecial.class"/>
<xs:group ref="Misc.class"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:attributeGroup name="label.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="for" type="xs:IDREF"/>
<xs:attribute name="accesskey" type="Character"/>
</xs:attributeGroup>
<xs:complexType name="label.type" mixed="true">
<xs:group ref="label.content"/>
<xs:attributeGroup ref="label.attlist"/>
</xs:complexType>
<xs:element name="label" type="label.type"/>
<!--
Basic Forms removes button, 'image' and 'file' input types.
-->
<xs:simpleType name="InputType.class">
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="text"/>
<xs:enumeration value="password"/>
<xs:enumeration value="checkbox"/>
<xs:enumeration value="radio"/>
<xs:enumeration value="submit"/>
<xs:enumeration value="reset"/>
<xs:enumeration value="hidden"/>
</xs:restriction>
</xs:simpleType>
<xs:attributeGroup name="input.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="type" type="InputType.class" default="text"/>
<xs:attribute name="name" type="CDATA"/>
<xs:attribute name="value" type="CDATA"/>
<xs:attribute name="checked">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="checked"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="size" type="Number"/>
<xs:attribute name="maxlength" type="Number"/>
<xs:attribute name="src" type="URI"/>
<xs:attribute name="tabindex" type="Number"/>
<xs:attribute name="accesskey" type="Character"/>
</xs:attributeGroup>
<xs:group name="input.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="input.type">
<xs:group ref="input.content"/>
<xs:attributeGroup ref="input.attlist"/>
</xs:complexType>
<xs:element name="input" type="input.type"/>
<xs:attributeGroup name="select.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="name" type="CDATA"/>
<xs:attribute name="size" type="Number"/>
<xs:attribute name="multiple">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="multiple"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="tabindex" type="Number"/>
</xs:attributeGroup>
<xs:group name="select.content">
<xs:sequence>
<xs:element ref="option" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="select.type">
<xs:group ref="select.content"/>
<xs:attributeGroup ref="select.attlist"/>
</xs:complexType>
<xs:element name="select" type="select.type"/>
<xs:attributeGroup name="option.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="selected">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="selected"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="value" type="CDATA"/>
<xs:attribute name="tabindex" type="Number"/>
</xs:attributeGroup>
<xs:group name="option.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="option.type" mixed="true">
<xs:group ref="option.content"/>
<xs:attributeGroup ref="option.attlist"/>
</xs:complexType>
<xs:element name="option" type="option.type"/>
<xs:attributeGroup name="textarea.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="name" type="CDATA"/>
<xs:attribute name="rows" type="Number" use="required"/>
<xs:attribute name="cols" type="Number" use="required"/>
<xs:attribute name="accesskey" type="Character"/>
</xs:attributeGroup>
<xs:group name="textarea.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="textarea.type" mixed="true">
<xs:group ref="textarea.content"/>
<xs:attributeGroup ref="textarea.attlist"/>
</xs:complexType>
<xs:element name="textarea" type="textarea.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Forms
This is the XML Schema Forms module for XHTML
* form, label, input, select, optgroup, option,
textarea, fieldset, legend, button
This module declares markup to provide support for online
forms, based on the features found in HTML 4.0 forms.
$Id: xhtml-form-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_extformsmodule"/>
</xs:annotation>
<!-- form: Form Element -->
<xs:attributeGroup name="form.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="action" type="URI" use="required"/>
<xs:attribute name="method" default="get">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="get"/>
<xs:enumeration value="post"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="enctype" type="ContentType" default="application/x-www-form-urlencoded"/>
<xs:attribute name="accept-charset" type="Charsets"/>
<xs:attribute name="accept" type="ContentTypes"/>
</xs:attributeGroup>
<xs:group name="form.content">
<xs:sequence>
<xs:choice maxOccurs="unbounded">
<xs:group ref="BlkNoForm.mix"/>
<xs:element ref="fieldset"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="form.type">
<xs:group ref="form.content"/>
<xs:attributeGroup ref="form.attlist"/>
</xs:complexType>
<xs:element name="form" type="form.type"/>
<!--
label: Form Field Label Text
Note: Each label must not contain more than ONE field
-->
<xs:group name="label.content">
<xs:sequence>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="input"/>
<xs:element ref="select"/>
<xs:element ref="textarea"/>
<xs:element ref="button"/>
<xs:group ref="InlStruct.class"/>
<xs:group ref="InlPhras.class"/>
<xs:group ref="I18n.class"/>
<xs:group ref="InlPres.class"/>
<xs:group ref="InlSpecial.class"/>
<xs:group ref="Inline.extra"/>
<xs:group ref="Misc.class"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:attributeGroup name="label.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="for" type="xs:IDREF"/>
<xs:attribute name="accesskey" type="Character"/>
</xs:attributeGroup>
<xs:complexType name="label.type" mixed="true">
<xs:group ref="label.content"/>
<xs:attributeGroup ref="label.attlist"/>
</xs:complexType>
<xs:element name="label" type="label.type"/>
<!-- input: Form Control -->
<xs:simpleType name="InputType.class">
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="text"/>
<xs:enumeration value="password"/>
<xs:enumeration value="checkbox"/>
<xs:enumeration value="radio"/>
<xs:enumeration value="submit"/>
<xs:enumeration value="reset"/>
<xs:enumeration value="hidden"/>
<xs:enumeration value="image"/>
<xs:enumeration value="button"/>
<xs:enumeration value="file"/>
</xs:restriction>
</xs:simpleType>
<!--
attribute 'name' required for all but submit & reset
-->
<xs:attributeGroup name="input.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="type" type="InputType.class" default="text"/>
<xs:attribute name="name" type="CDATA"/>
<xs:attribute name="value" type="CDATA"/>
<xs:attribute name="checked">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="checked"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="disabled">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="disabled"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="readonly">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="readonly"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="size" type="Number"/>
<xs:attribute name="maxlength" type="Number"/>
<xs:attribute name="src" type="URI"/>
<xs:attribute name="alt" type="Text"/>
<xs:attribute name="tabindex" type="Number"/>
<xs:attribute name="accesskey" type="Character"/>
<xs:attribute name="accept" type="ContentTypes"/>
</xs:attributeGroup>
<xs:group name="input.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="input.type">
<xs:group ref="input.content"/>
<xs:attributeGroup ref="input.attlist"/>
</xs:complexType>
<xs:element name="input" type="input.type"/>
<!-- select: Option Selector -->
<xs:attributeGroup name="select.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="name" type="CDATA"/>
<xs:attribute name="size" type="Number"/>
<xs:attribute name="multiple">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="multiple"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="disabled">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="disabled"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="tabindex" type="Number"/>
</xs:attributeGroup>
<xs:group name="select.content">
<xs:sequence>
<xs:choice minOccurs="1" maxOccurs="unbounded">
<xs:element ref="optgroup"/>
<xs:element ref="option"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="select.type">
<xs:group ref="select.content"/>
<xs:attributeGroup ref="select.attlist"/>
</xs:complexType>
<xs:element name="select" type="select.type"/>
<!-- optgroup: Option Group -->
<xs:attributeGroup name="optgroup.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="disabled">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="disabled"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="label" type="Text" use="required"/>
</xs:attributeGroup>
<xs:group name="optgroup.content">
<xs:sequence>
<xs:element ref="option" minOccurs="1" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="optgroup.type">
<xs:group ref="optgroup.content"/>
<xs:attributeGroup ref="optgroup.attlist"/>
</xs:complexType>
<xs:element name="optgroup" type="optgroup.type"/>
<!-- option: Selectable Choice -->
<xs:attributeGroup name="option.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="selected">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="selected"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="disabled">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="disabled"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="label" type="Text"/>
<xs:attribute name="value" type="CDATA"/>
</xs:attributeGroup>
<xs:group name="option.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="option.type" mixed="true">
<xs:group ref="option.content"/>
<xs:attributeGroup ref="option.attlist"/>
</xs:complexType>
<xs:element name="option" type="option.type"/>
<!-- textarea: Multi-Line Text Field -->
<xs:attributeGroup name="textarea.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="name" type="CDATA"/>
<xs:attribute name="rows" type="Number" use="required"/>
<xs:attribute name="cols" type="Number" use="required"/>
<xs:attribute name="disabled">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="disabled"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="readonly">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="readonly"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="tabindex" type="Number"/>
<xs:attribute name="accesskey" type="Character"/>
</xs:attributeGroup>
<xs:group name="textarea.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="textarea.type" mixed="true">
<xs:group ref="textarea.content"/>
<xs:attributeGroup ref="textarea.attlist"/>
</xs:complexType>
<xs:element name="textarea" type="textarea.type"/>
<!-- fieldset: Form Control Group -->
<xs:attributeGroup name="fieldset.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="fieldset.content">
<xs:sequence>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="legend"/>
<xs:group ref="Flow.mix"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="fieldset.type" mixed="true">
<xs:group ref="fieldset.content"/>
<xs:attributeGroup ref="fieldset.attlist"/>
</xs:complexType>
<xs:element name="fieldset" type="fieldset.type"/>
<!-- legend: Fieldset Legend -->
<xs:attributeGroup name="legend.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="accesskey" type="Character"/>
</xs:attributeGroup>
<xs:group name="legend.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="legend.type" mixed="true">
<xs:group ref="legend.content"/>
<xs:attributeGroup ref="legend.attlist"/>
</xs:complexType>
<xs:element name="legend" type="legend.type"/>
<!-- button: Push Button -->
<xs:attributeGroup name="button.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="name" type="CDATA"/>
<xs:attribute name="value" type="CDATA"/>
<xs:attribute name="type" default="submit">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="button"/>
<xs:enumeration value="submit"/>
<xs:enumeration value="reset"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="disabled">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="disabled"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="tabindex" type="Number"/>
<xs:attribute name="accesskey" type="Character"/>
</xs:attributeGroup>
<xs:group name="button.content">
<xs:sequence>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:group ref="BlkNoForm.mix"/>
<xs:group ref="InlStruct.class"/>
<xs:group ref="InlPhras.class"/>
<xs:group ref="InlPres.class"/>
<xs:group ref="BlkPres.class"/>
<xs:group ref="I18n.class"/>
<xs:group ref="InlSpecial.class"/>
<xs:group ref="Inline.extra"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="button.type" mixed="true">
<xs:group ref="button.content"/>
<xs:attributeGroup ref="button.attlist"/>
</xs:complexType>
<xs:element name="button" type="button.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Basic Tables module for XHTML
$Id: xhtml-basic-table-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Basic Tables
* table, caption, tr, th, td
This table module declares elements and attributes defining
a table model based fundamentally on features found in the
widely-deployed HTML 3.2 table model. While this module
mimics the content model and table attributes of HTML 3.2
tables, the element types declared herein also includes all
HTML 4 common and most of the HTML 4 table attributes.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_simpletablemodule"/>
</xs:annotation>
<xs:attributeGroup name="CellHAlign.attrib">
<xs:attribute name="align">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="left"/>
<xs:enumeration value="center"/>
<xs:enumeration value="right"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="CellVAlign.attrib">
<xs:attribute name="valign">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="top"/>
<xs:enumeration value="middle"/>
<xs:enumeration value="bottom"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="scope.attrib">
<xs:attribute name="scope">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="row"/>
<xs:enumeration value="col"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="table.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="summary" type="Text"/>
</xs:attributeGroup>
<xs:group name="table.content">
<xs:sequence>
<xs:element ref="caption" minOccurs="0" maxOccurs="1"/>
<xs:element ref="tr" maxOccurs="unbounded" />
</xs:sequence>
</xs:group>
<xs:complexType name="table.type" >
<xs:group ref="table.content"/>
<xs:attributeGroup ref="table.attlist"/>
</xs:complexType>
<xs:element name="table" type="table.type"/>
<xs:attributeGroup name="caption.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="caption.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="caption.type" mixed="true" >
<xs:group ref="caption.content"/>
<xs:attributeGroup ref="caption.attlist"/>
</xs:complexType>
<xs:element name="caption" type="caption.type"/>
<xs:attributeGroup name="tr.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="tr.content">
<xs:sequence>
<xs:choice maxOccurs="unbounded">
<xs:element ref="th"/>
<xs:element ref="td"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="tr.type">
<xs:group ref="tr.content"/>
<xs:attributeGroup ref="tr.attlist"/>
</xs:complexType>
<xs:element name="tr" type="tr.type"/>
<xs:attributeGroup name="th.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="abbr" type="Text"/>
<xs:attribute name="axis" type="CDATA"/>
<xs:attribute name="headers" type="xs:IDREFS"/>
<xs:attributeGroup ref="scope.attrib"/>
<xs:attribute name="rowspan" type="Number" default="1"/>
<xs:attribute name="colspan" type="Number" default="1"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="th.content">
<xs:sequence>
<xs:group ref="FlowNoTable.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="th.type" mixed="true">
<xs:group ref="th.content"/>
<xs:attributeGroup ref="th.attlist"/>
</xs:complexType>
<xs:element name="th" type="th.type"/>
<xs:attributeGroup name="td.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="abbr" type="Text"/>
<xs:attribute name="axis" type="CDATA"/>
<xs:attribute name="headers" type="xs:IDREFS"/>
<xs:attributeGroup ref="scope.attrib"/>
<xs:attribute name="rowspan" type="Number" default="1"/>
<xs:attribute name="colspan" type="Number" default="1"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="td.content">
<xs:sequence>
<xs:group ref="FlowNoTable.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="td.type" mixed="true">
<xs:group ref="td.content"/>
<xs:attributeGroup ref="td.attlist"/>
</xs:complexType>
<xs:element name="td" type="td.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema">
<xs:annotation>
<xs:documentation>
This is the XML Schema Tables module for XHTML
$Id: xhtml-table-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Tables
* table, caption, thead, tfoot, tbody, colgroup, col, tr, th, td
This module declares element types and attributes used to provide
table markup similar to HTML 4.0, including features that enable
better accessibility for non-visual user agents.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_tablemodule"/>
</xs:annotation>
<xs:attributeGroup name="frame.attrib">
<xs:attribute name="frame">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="void"/>
<xs:enumeration value="above"/>
<xs:enumeration value="below"/>
<xs:enumeration value="hsides"/>
<xs:enumeration value="lhs"/>
<xs:enumeration value="rhs"/>
<xs:enumeration value="vsides"/>
<xs:enumeration value="box"/>
<xs:enumeration value="border"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="rules.attrib">
<xs:attribute name="rules">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="none"/>
<xs:enumeration value="groups"/>
<xs:enumeration value="rows"/>
<xs:enumeration value="cols"/>
<xs:enumeration value="all"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="CellVAlign.attrib">
<xs:attribute name="valign">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="top"/>
<xs:enumeration value="middle"/>
<xs:enumeration value="bottom"/>
<xs:enumeration value="baseline"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="CellHAlign.attrib">
<xs:attribute name="align">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="left"/>
<xs:enumeration value="center"/>
<xs:enumeration value="right"/>
<xs:enumeration value="justify"/>
<xs:enumeration value="char"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="char" type="Character"/>
<xs:attribute name="charoff" type="Length"/>
</xs:attributeGroup>
<xs:attributeGroup name="scope.attrib">
<xs:attribute name="scope">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="row"/>
<xs:enumeration value="col"/>
<xs:enumeration value="rowgroup"/>
<xs:enumeration value="colgroup"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="td.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="abbr" type="Text"/>
<xs:attribute name="axis" type="CDATA"/>
<xs:attribute name="headers" type="xs:IDREFS"/>
<xs:attributeGroup ref="scope.attrib"/>
<xs:attribute name="rowspan" type="Number" default="1"/>
<xs:attribute name="colspan" type="Number" default="1"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="td.content">
<xs:sequence>
<xs:group ref="Flow.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="td.type" mixed="true">
<xs:group ref="td.content"/>
<xs:attributeGroup ref="td.attlist"/>
</xs:complexType>
<xs:element name="td" type="td.type"/>
<xs:attributeGroup name="th.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="abbr" type="Text"/>
<xs:attribute name="axis" type="CDATA"/>
<xs:attribute name="headers" type="xs:IDREFS"/>
<xs:attributeGroup ref="scope.attrib"/>
<xs:attribute name="rowspan" type="Number" default="1"/>
<xs:attribute name="colspan" type="Number" default="1"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="th.content">
<xs:sequence>
<xs:group ref="Flow.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="th.type" mixed="true">
<xs:group ref="th.content"/>
<xs:attributeGroup ref="th.attlist"/>
</xs:complexType>
<xs:element name="th" type="th.type"/>
<xs:attributeGroup name="tr.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="tr.content">
<xs:sequence>
<xs:choice maxOccurs="unbounded">
<xs:element ref="th"/>
<xs:element ref="td"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="tr.type">
<xs:group ref="tr.content"/>
<xs:attributeGroup ref="tr.attlist"/>
</xs:complexType>
<xs:element name="tr" type="tr.type"/>
<xs:attributeGroup name="col.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="span" type="Number" default="1"/>
<xs:attribute name="width" type="MultiLength"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="col.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="col.type">
<xs:group ref="col.content"/>
<xs:attributeGroup ref="col.attlist"/>
</xs:complexType>
<xs:element name="col" type="col.type"/>
<xs:attributeGroup name="colgroup.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="span" type="Number" default="1"/>
<xs:attribute name="width" type="MultiLength"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="colgroup.content">
<xs:sequence>
<xs:element ref="col" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="colgroup.type">
<xs:group ref="colgroup.content"/>
<xs:attributeGroup ref="colgroup.attlist"/>
</xs:complexType>
<xs:element name="colgroup" type="colgroup.type"/>
<xs:attributeGroup name="tbody.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="tbody.content">
<xs:sequence>
<xs:element ref="tr" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="tbody.type">
<xs:group ref="tbody.content"/>
<xs:attributeGroup ref="tbody.attlist"/>
</xs:complexType>
<xs:element name="tbody" type="tbody.type"/>
<xs:attributeGroup name="tfoot.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="tfoot.content">
<xs:sequence>
<xs:element ref="tr" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="tfoot.type">
<xs:group ref="tfoot.content"/>
<xs:attributeGroup ref="tfoot.attlist"/>
</xs:complexType>
<xs:element name="" type="tfoot.type"/>
<xs:attributeGroup name="thead.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attributeGroup ref="CellHAlign.attrib"/>
<xs:attributeGroup ref="CellVAlign.attrib"/>
</xs:attributeGroup>
<xs:group name="thead.content">
<xs:sequence>
<xs:element ref="tr" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="thead.type">
<xs:group ref="thead.content"/>
<xs:attributeGroup ref="thead.attlist"/>
</xs:complexType>
<xs:element name="thead" type="thead.type"/>
<xs:attributeGroup name="caption.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="caption.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="caption.type" mixed="true">
<xs:group ref="caption.content"/>
<xs:attributeGroup ref="caption.attlist"/>
</xs:complexType>
<xs:element name="caption" type="caption.type"/>
<xs:attributeGroup name="table.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="summary" type="Text"/>
<xs:attribute name="width" type="Length"/>
<xs:attribute name="border" type="Pixels"/>
<xs:attributeGroup ref="frame.attrib"/>
<xs:attributeGroup ref="rules.attrib"/>
<xs:attribute name="cellspacing" type="Length"/>
<xs:attribute name="cellpadding" type="Length"/>
</xs:attributeGroup>
<xs:group name="table.content">
<xs:sequence>
<xs:element ref="caption" minOccurs="0"/>
<xs:choice>
<xs:element ref="col" minOccurs="0" maxOccurs="unbounded"/>
<xs:element ref="colgroup" minOccurs="0" maxOccurs="unbounded"/>
</xs:choice>
<xs:choice>
<xs:sequence>
<xs:element ref="thead" minOccurs="0"/>
<xs:element ref="tfoot" minOccurs="0"/>
<xs:element ref="tbody" maxOccurs="unbounded"/>
</xs:sequence>
<xs:choice>
<xs:element ref="tr" maxOccurs="unbounded"/>
</xs:choice>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="table.type">
<xs:group ref="table.content"/>
<xs:attributeGroup ref="table.attlist"/>
</xs:complexType>
<xs:element name="table" type="table.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Images
This is the XML Schema Images module for XHTML
* img
This module provides markup to support basic image embedding.
To avoid problems with text-only UAs as well as to make
image content understandable and navigable to users of
non-visual UAs, you need to provide a description with
the 'alt' attribute, and avoid server-side image maps.
$Id: xhtml-image-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_imagemodule"/>
</xs:annotation>
<xs:attributeGroup name="img.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="src" type="URI" use="required"/>
<xs:attribute name="alt" type="Text" use="required"/>
<xs:attribute name="longdesc" type="URI"/>
<xs:attribute name="height" type="Length"/>
<xs:attribute name="width" type="Length"/>
</xs:attributeGroup>
<xs:group name="img.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="img.type">
<xs:group ref="img.content"/>
<xs:attributeGroup ref="img.attlist"/>
</xs:complexType>
<xs:element name="img" type="img.type"/>
</xs:schema>
C.3.7. Client-side Image Map
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Client-side Image Maps
This is the XML Schema Client-side Image Maps module for XHTML
* area, map
This module declares elements and attributes to support client-side
image maps.
$Id: xhtml-csismap-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_imapmodule"/>
</xs:annotation>
<xs:simpleType name="Shape.Datatype">
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="rect"/>
<xs:enumeration value="circle"/>
<xs:enumeration value="poly"/>
<xs:enumeration value="default"/>
</xs:restriction>
</xs:simpleType>
<xs:simpleType name="Coords.Datatype">
<xs:restriction base="Text"/>
</xs:simpleType>
<!-- modify anchor attribute definition list -->
<xs:attributeGroup name="a.csim.attlist">
<xs:attribute name="shape" type="Shape.Datatype" default="rect"/>
<xs:attribute name="coords" type="Coords.Datatype"/>
</xs:attributeGroup>
<!-- modify img attribute definition list -->
<xs:attributeGroup name="img.csim.attlist">
<xs:attribute name="usemap" type="xs:IDREF"/>
</xs:attributeGroup>
<!-- modify form input attribute definition list -->
<xs:attributeGroup name="input.csim.attlist">
<xs:attribute name="usemap" type="xs:IDREF"/>
</xs:attributeGroup>
<!-- modify object attribute definition list -->
<xs:attributeGroup name="object.csim.attlist">
<xs:attribute name="usemap" type="xs:IDREF"/>
</xs:attributeGroup>
<xs:attributeGroup name="area.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="href" type="URI"/>
<xs:attribute name="shape" type="Shape.Datatype" default="rect"/>
<xs:attribute name="coords" type="Coords.Datatype"/>
<xs:attribute name="nohref">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="nohref"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="alt" type="Text" use="required"/>
<xs:attribute name="tabindex" type="Number"/>
<xs:attribute name="accesskey" type="Character"/>
</xs:attributeGroup>
<xs:group name="area.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="area.type">
<xs:group ref="area.content"/>
<xs:attributeGroup ref="area.attlist"/>
</xs:complexType>
<xs:element name="area" type="area.type"/>
<!-- map -->
<xs:attributeGroup name="map.attlist">
<xs:attribute name="id" type="xs:ID" use="required"/>
<xs:attributeGroup ref="class"/>
<xs:attributeGroup ref="title"/>
<xs:attributeGroup ref="Core.extra.attrib"/>
<xs:attributeGroup ref="I18n.attrib"/>
</xs:attributeGroup>
<xs:group name="map.content">
<xs:sequence>
<xs:choice maxOccurs="unbounded">
<xs:group ref="Block.mix"/>
<xs:element ref="area"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="map.type">
<xs:group ref="map.content"/>
<xs:attributeGroup ref="map.attlist"/>
</xs:complexType>
<xs:element name="map" type="map.type"/>
</xs:schema>
C.3.8. Server-side Image Map
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Server-side Image Maps module for XHTML
$Id: xhtml-ssismap-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Server-side Image Maps
This adds the 'ismap' attribute to the img element to
support server-side processing of a user selection.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_servermapmodule"/>
</xs:annotation>
<xs:attributeGroup name="img.ssimap.attlist">
<xs:attribute name="ismap">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="ismap"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="input.ssimap.attlist">
<xs:attribute name="ismap">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="ismap"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Embedded Object module for XHTML
$Id: xhtml-object-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
This module declares the object element type and its attributes,
used to embed external objects as part of XHTML pages. In the
document, place param elements prior to the object elements
that require their content.
Note that use of this module requires instantiation of the
Param Element Module prior to this module.
Elements defined here:
* object (param)
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_objectmodule"/>
</xs:annotation>
<xs:include schemaLocation="xhtml-param-1.xsd">
<xs:annotation>
<xs:documentation>
Param module
Elements defined here:
* param
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:attributeGroup name="object.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="declare">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="declare"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="classid" type="URI"/>
<xs:attribute name="codebase" type="URI"/>
<xs:attribute name="data" type="URI"/>
<xs:attribute name="type" type="ContentType"/>
<xs:attribute name="codetype" type="ContentType"/>
<xs:attribute name="archive" type="URIs"/>
<xs:attribute name="standby" type="Text"/>
<xs:attribute name="height" type="Length"/>
<xs:attribute name="width" type="Length"/>
<xs:attribute name="name" type="CDATA"/>
<xs:attribute name="tabindex" type="Number"/>
</xs:attributeGroup>
<xs:group name="object.content">
<xs:sequence>
<xs:choice minOccurs="0" maxOccurs="unbounded">
<xs:element ref="param"/>
<xs:group ref="Flow.mix"/>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:complexType name="object.type" mixed="true">
<xs:group ref="object.content"/>
<xs:attributeGroup ref="object.attlist"/>
</xs:complexType>
<xs:element name="object" type="object.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Frames module for XHTML
$Id: xhtml-frames-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Frames
* frameset, frame, noframes
This module declares frame-related element types and attributes.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_framesmodule"/>
</xs:annotation>
<xs:attributeGroup name="frameset.attlist">
<xs:attributeGroup ref="Core.attrib"/>
<xs:attribute name="rows" type="MultiLengths"/>
<xs:attribute name="cols" type="MultiLengths"/>
</xs:attributeGroup>
<xs:group name="frameset.content">
<xs:sequence>
<xs:choice minOccurs="1" maxOccurs="unbounded">
<xs:element ref="frameset"/>
<xs:element ref="frame"/>
</xs:choice>
<xs:element ref="noframes" minOccurs="0" maxOccurs="1"/>
</xs:sequence>
</xs:group>
<xs:complexType name="frameset.type" mixed="true">
<xs:group ref="frameset.content"/>
<xs:attributeGroup ref="frameset.attlist"/>
</xs:complexType>
<xs:element name="frameset" type="frameset.type"/>
<!--
reserved frame names start with "_"
otherwise starts with letter
-->
<xs:attributeGroup name="frame.attlist">
<xs:attributeGroup ref="Core.attrib"/>
<xs:attribute name="longdesc" type="URI"/>
<xs:attribute name="src" type="URI"/>
<xs:attribute name="frameborder" default="1">
<xs:simpleType>
<xs:restriction base="xs:nonNegativeInteger">
<xs:enumeration value="1"/>
<xs:enumeration value="0"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="marginwidth" type="Pixels"/>
<xs:attribute name="marginheight" type="Pixels"/>
<xs:attribute name="noresize">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="noresize"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="scrolling" default="auto">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="yes"/>
<xs:enumeration value="no"/>
<xs:enumeration value="auto"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:group name="frame.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="frame.type">
<xs:group ref="frame.content"/>
<xs:attributeGroup ref="frame.attlist"/>
</xs:complexType>
<xs:element name="frame" type="frame.type"/>
<!--
noframes
-->
<xs:group name="noframes.content">
<xs:sequence>
<xs:element ref="body"/>
</xs:sequence>
</xs:group>
<xs:attributeGroup name="noframes.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:complexType name="noframes.type" mixed="true">
<xs:group ref="noframes.content"/>
<xs:attributeGroup ref="noframes.attlist"/>
</xs:complexType>
<xs:element name="noframes" type="noframes.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Target module for XHTML
$Id: xhtml-target-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Target
* target
This module declares the 'target' attribute used for opening windows
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_targetmodule"/>
</xs:annotation>
<xs:simpleType name="FrameTarget">
<xs:restriction base="xs:string"/>
</xs:simpleType>
<xs:attributeGroup name="base.target.attlist">
<xs:attribute name="target" type="FrameTarget"/>
</xs:attributeGroup>
<xs:attributeGroup name="form.target.attlist">
<xs:attribute name="target" type="FrameTarget"/>
</xs:attributeGroup>
<xs:attributeGroup name="link.target.attlist">
<xs:attribute name="target" type="FrameTarget"/>
</xs:attributeGroup>
<xs:attributeGroup name="area.target.attlist">
<xs:attribute name="target" type="FrameTarget"/>
</xs:attributeGroup>
<xs:attributeGroup name="a.target.attlist">
<xs:attribute name="target" type="FrameTarget"/>
</xs:attributeGroup>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Inline Frame Element module for XHTML
$Id: xhtml-iframe-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Inline Frames
* iframe
This module declares the iframe element type and its attributes,
used to create an inline frame within a document.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_iframemodule"/>
</xs:annotation>
<xs:attributeGroup name="iframe.attlist">
<xs:attributeGroup ref="Core.attrib"/>
<xs:attribute name="longdesc" type="URI"/>
<xs:attribute name="src" type="URI"/>
<xs:attribute name="frameborder" default="1">
<xs:simpleType>
<xs:restriction base="xs:nonNegativeInteger">
<xs:enumeration value="1"/>
<xs:enumeration value="0"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="marginwidth" type="Pixels"/>
<xs:attribute name="marginheight" type="Pixels"/>
<xs:attribute name="scrolling" default="auto">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="yes"/>
<xs:enumeration value="no"/>
<xs:enumeration value="auto"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="height" type="Length"/>
<xs:attribute name="width" type="Length"/>
</xs:attributeGroup>
<xs:group name="iframe.content">
<xs:sequence>
<xs:group ref="Flow.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="iframe.type" mixed="true">
<xs:group ref="iframe.content"/>
<xs:attributeGroup ref="iframe.attlist"/>
</xs:complexType>
<xs:element name="iframe" type="iframe.type"/>
</xs:schema>
C.3.13. Intrinsic Events
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Intrinsic Event Attributes
This is the XML Schema Intrinsic Events module for XHTML
These are the event attributes defined in HTML 4,
Section 18.2.3 "Intrinsic Events".
"Note: Authors of HTML documents are advised that changes
are likely to occur in the realm of intrinsic events
(e.g., how scripts are bound to events). Research in
this realm is carried on by members of the W3C Document
Object Model Working Group (see the W3C Web site at
http://www.w3.org/ for more information)."
$Id: xhtml-events-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_intrinsiceventsmodule"/>
</xs:annotation>
<xs:attributeGroup name="Events.attrib">
<xs:attribute name="onclick" type="Script"/>
<xs:attribute name="ondblclick" type="Script"/>
<xs:attribute name="onmousedown" type="Script"/>
<xs:attribute name="onmouseup" type="Script"/>
<xs:attribute name="onmouseover" type="Script"/>
<xs:attribute name="onmousemove" type="Script"/>
<xs:attribute name="onmouseout" type="Script"/>
<xs:attribute name="onkeypress" type="Script"/>
<xs:attribute name="onkeydown" type="Script"/>
<xs:attribute name="onkeyup" type="Script"/>
</xs:attributeGroup>
<!--
additional attributes on anchor element
-->
<xs:attributeGroup name="a.events.attlist">
<xs:attribute name="onfocus" type="Script"/>
<xs:attribute name="onblur" type="Script"/>
</xs:attributeGroup>
<!--
additional attributes on form element
-->
<xs:attributeGroup name="form.events.attlist">
<xs:attribute name="onsubmit" type="Script"/>
<xs:attribute name="onreset" type="Script"/>
</xs:attributeGroup>
<!--
additional attributes on label element
-->
<xs:attributeGroup name="label.events.attlist">
<xs:attribute name="onfocus" type="Script"/>
<xs:attribute name="onblur" type="Script"/>
</xs:attributeGroup>
<!--
additional attributes on input element
-->
<xs:attributeGroup name="input.events.attlist">
<xs:attribute name="onfocus" type="Script"/>
<xs:attribute name="onblur" type="Script"/>
<xs:attribute name="onselect" type="Script"/>
<xs:attribute name="onchange" type="Script"/>
</xs:attributeGroup>
<!--
additional attributes on select element
-->
<xs:attributeGroup name="select.events.attlist">
<xs:attribute name="onfocus" type="Script"/>
<xs:attribute name="onblur" type="Script"/>
<xs:attribute name="onchange" type="Script"/>
</xs:attributeGroup>
<!--
additional attributes on textarea element
-->
<xs:attributeGroup name="textarea.events.attlist">
<xs:attribute name="onfocus" type="Script"/>
<xs:attribute name="onblur" type="Script"/>
<xs:attribute name="onselect" type="Script"/>
<xs:attribute name="onchange" type="Script"/>
</xs:attributeGroup>
<!--
additional attributes on button element
-->
<xs:attributeGroup name="button.events.attlist">
<xs:attribute name="onfocus" type="Script"/>
<xs:attribute name="onblur" type="Script"/>
</xs:attributeGroup>
<!--
additional attributes on body element
-->
<xs:attributeGroup name="body.events.attlist">
<xs:attribute name="onload" type="Script"/>
<xs:attribute name="onunload" type="Script"/>
</xs:attributeGroup>
<!--
additional attributes on area element
-->
<xs:attributeGroup name="area.events.attlist">
<xs:attribute name="onfocus" type="Script"/>
<xs:attribute name="onblur" type="Script"/>
</xs:attributeGroup>
</xs:schema>
C.3.14. Metainformation
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Metainformation module for XHTML
$Id: xhtml-meta-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Meta Information
* meta
This module declares the meta element type and its attributes,
used to provide declarative document metainformation.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_metamodule"/>
</xs:annotation>
<xs:attributeGroup name="meta.attlist">
<xs:attributeGroup ref="I18n.attrib"/>
<xs:attribute name="http-equiv" type="xs:NMTOKEN"/>
<xs:attribute name="name" type="xs:NMTOKEN"/>
<xs:attribute name="content" type="CDATA" use="required"/>
<xs:attribute name="scheme" type="CDATA"/>
</xs:attributeGroup>
<xs:group name="meta.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="meta.type">
<xs:group ref="meta.content"/>
<xs:attributeGroup ref="meta.attlist"/>
</xs:complexType>
<xs:element name="meta" type="meta.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xml="http://www.w3.org/XML/1998/namespace"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Scripting module for XHTML
$Id: xhtml-script-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Scripting
* script, noscript
This module declares element types and attributes used to provide
support for executable scripts as well as an alternate content
container where scripts are not supported.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_scriptmodule"/>
</xs:annotation>
<xs:attributeGroup name="script.attlist">
<xs:attribute name="charset" type="Charset"/>
<xs:attribute name="type" type="ContentType" use="required"/>
<xs:attribute name="src" type="URI"/>
<xs:attribute name="defer">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="defer"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute ref="xml:space" fixed="preserve"/>
</xs:attributeGroup>
<xs:group name="script.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="script.type" mixed="true">
<xs:group ref="script.content"/>
<xs:attributeGroup ref="script.attlist"/>
</xs:complexType>
<xs:element name="script" type="script.type"/>
<xs:attributeGroup name="noscript.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="noscript.content">
<xs:sequence>
<xs:group ref="Block.mix" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="noscript.type">
<xs:group ref="noscript.content"/>
<xs:attributeGroup ref="noscript.attlist"/>
</xs:complexType>
<xs:element name="noscript" type="noscript.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns:xml="http://www.w3.org/XML/1998/namespace"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Stylesheets module for XHTML
$Id: xhtml-style-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Stylesheets
* style
This module declares the style element type and its attributes,
used to embed stylesheet information in the document head element.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_stylemodule"/>
</xs:annotation>
<xs:attributeGroup name="style.attlist">
<xs:attributeGroup ref="title"/>
<xs:attributeGroup ref="I18n.attrib"/>
<xs:attribute name="type" type="ContentType" use="required"/>
<xs:attribute name="media" type="MediaDesc"/>
<xs:attribute ref="xml:space" fixed="preserve"/>
</xs:attributeGroup>
<xs:group name="style.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="style.type" mixed="true">
<xs:group ref="style.content"/>
<xs:attributeGroup ref="style.attlist"/>
</xs:complexType>
<xs:element name="style" type="style.type"/>
</xs:schema>
C.3.17. Style Attribute
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Inline Style module
This is the XML Schema Inline Style module for XHTML
* styloe attribute
This module declares the 'style' attribute, used to support inline
style markup.
$Id: xhtml-inlstyle-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_styleattributemodule"/>
</xs:annotation>
<xs:attributeGroup name="style.attrib">
<xs:attribute name="style" type="CDATA"/>
</xs:attributeGroup>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Link Element module for XHTML
$Id: xhtml-link-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Link element
* link
This module declares the link element type and its attributes,
which could (in principle) be used to define document-level links
to external resources.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_linkmodule"/>
</xs:annotation>
<xs:attributeGroup name="link.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="charset" type="Charset"/>
<xs:attribute name="href" type="URI"/>
<xs:attribute name="hreflang" type="LanguageCode"/>
<xs:attribute name="type" type="ContentType"/>
<xs:attribute name="rel" type="LinkTypes"/>
<xs:attribute name="rev" type="LinkTypes"/>
<xs:attribute name="media" type="MediaDesc"/>
</xs:attributeGroup>
<xs:group name="link.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="link.type">
<xs:group ref="link.content"/>
<xs:attributeGroup ref="link.attlist"/>
</xs:complexType>
<xs:element name="link" type="link.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Base element
This is the XML Schema Base Element module for XHTML
* base
This module declares the base element type and its attributes,
used to define a base URI against which relative URIs in the
document will be resolved.
$Id: xhtml-base-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_basemodule"/>
</xs:annotation>
<xs:attributeGroup name="base.attlist">
<xs:attribute name="href" type="URI" use="required"/>
</xs:attributeGroup>
<xs:group name="base.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="base.type">
<xs:group ref="base.content"/>
<xs:attributeGroup ref="base.attlist"/>
</xs:complexType>
<xs:element name="base" type="base.type"/>
</xs:schema>
C.3.20. Name Identification
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Name Identifier module for XHTML
$Id: xhtml-nameident-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Name Identifier
* 'name' attribute on form, img, a, map, applet, frame, iframe
This module declares the 'name' attribute on element types when
it is used as a node identifier for legacy linking and scripting
support. This does not include those instances when 'name' is used
as a container for form control, property or metainformation names.
This module should be instantiated following all modules it modifies.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_nameidentmodule"/>
</xs:annotation>
<xs:attributeGroup name="form.name.attlist">
<xs:attribute name="name" type="CDATA"/>
</xs:attributeGroup>
<xs:attributeGroup name="img.name.attlist">
<xs:attribute name="name" type="CDATA"/>
</xs:attributeGroup>
<xs:attributeGroup name="a.name.attlist">
<xs:attribute name="name" type="CDATA"/>
</xs:attributeGroup>
<xs:attributeGroup name="map.name.attlist">
<xs:attribute name="name" type="CDATA"/>
</xs:attributeGroup>
<xs:attributeGroup name="applet.name.attlist">
<xs:attribute name="name" type="CDATA"/>
</xs:attributeGroup>
<xs:attributeGroup name="frame.name.attlist">
<xs:attribute name="name" type="CDATA"/>
</xs:attributeGroup>
<xs:attributeGroup name="iframe.name.attlist">
<xs:attribute name="name" type="CDATA"/>
</xs:attributeGroup>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Module for HTML Legacy Markup
font, basefont, center, s, strike, u,
dir, menu, isindex
(plus additional datatypes and legacy attributes)
This optional module declares additional markup for simple
presentation-related markup based on features found in the
HTML 4 Transitional and Frameset DTDs.
The legacy module also include frames module, iframe module
and target module. (Note: This module expects find the schema files
of that declare these module)
Elements/Attributes defined in frame, iframe and targer modules are
* frameset, frame, noframes, att:target, iframe
$Id: xhtml-legacy-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_legacymodule"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_framesmodule"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_targetmodule"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_iframemodule"/>
</xs:annotation>
<xs:include schemaLocation="xhtml-misc-1.xsd">
<xs:annotation>
<xs:documentation>
Miscellaneous module
Attributes defined here:
* font, basefont, center, s, strike, u, dir, menu, isindex
(plus additional datatypes and attributes)
</xs:documentation>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="xhtml-frames-1.xsd">
<xs:annotation>
<xs:documentation>
Frames module
Elements defined here:
* frameset, frame, noframes
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_framesmodule"/>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="xhtml-target-1.xsd">
<xs:annotation>
<xs:documentation>
Target module
Attributes defined here:
* target
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_targetmodule"/>
</xs:annotation>
</xs:include>
<xs:include schemaLocation="xhtml-iframe-1.xsd">
<xs:annotation>
<xs:documentation>
Iframe module
Elements defined here:
* iframe
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_iframemodule"/>
</xs:annotation>
</xs:include>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the Ruby module for XHTML
$Id: xhtml-ruby-1.xsd,v 1.3 2003/09/22 19:05:41 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
"Ruby" are short runs of text alongside the base text, typically
used in East Asian documents to indicate pronunciation or to
provide a short annotation. The full specification for Ruby is here:
http://www.w3.org/TR/ruby
This module defines "Ruby " or "complex Ruby" as described
in the specification:
http://www.w3.org/TR/ruby/#complex
Simple or Basic Ruby are defined in a separate module.
This module expects the document model to define the
following content models
+ InlNoRuby.mix
</xs:documentation>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Ruby Elements
* ruby, rbc, rtc, rb, rt, rp
This module declares the elements and their attributes used to
support complex ruby annotation markup.
</xs:documentation>
</xs:annotation>
<xs:group name="ruby.content.simple">
<xs:sequence>
<xs:element ref="rb"/>
<xs:choice>
<xs:element ref="rt"/>
<xs:sequence>
<xs:element ref="rp"/>
<xs:element ref="rt"/>
<xs:element ref="rp"/>
</xs:sequence>
</xs:choice>
</xs:sequence>
</xs:group>
<xs:group name="ruby.content.complex">
<xs:sequence>
<xs:element ref="rbc"/>
<xs:element ref="rtc" maxOccurs="2"/>
</xs:sequence>
</xs:group>
<!--
add to this group any common attributes for all Ruby elements
-->
<xs:attributeGroup name="ruby.common.attrib"/>
<xs:group name="ruby.content">
<xs:choice>
<xs:group ref="ruby.content.simple"/>
<xs:group ref="ruby.content.complex"/>
</xs:choice>
</xs:group>
<xs:complexType name="ruby.type">
<xs:group ref="ruby.content"/>
<xs:attributeGroup ref="ruby.common.attrib"/>
</xs:complexType>
<xs:element name="ruby" type="ruby.type"/>
<!--
rbc (ruby base component) element
-->
<xs:attributeGroup name="rbc.attlist">
<xs:attributeGroup ref="ruby.common.attrib"/>
</xs:attributeGroup>
<xs:group name="rbc.content">
<xs:sequence>
<xs:element ref="rb"/>
</xs:sequence>
</xs:group>
<xs:complexType name="rbc.type">
<xs:group ref="rbc.content"/>
<xs:attributeGroup ref="rbc.attlist"/>
</xs:complexType>
<xs:element name="rbc" type="rbc.type"/>
<!--
rtc (ruby text component) element
-->
<xs:attributeGroup name="rtc.attlist">
<xs:attributeGroup ref="ruby.common.attrib"/>
</xs:attributeGroup>
<xs:group name="rtc.content">
<xs:sequence>
<xs:element ref="rt" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="rtc.type">
<xs:group ref="rt.content"/>
<xs:attributeGroup ref="rtc.attlist"/>
</xs:complexType>
<xs:element name="rtc" type="rtc.type"/>
<!--
rb (ruby base) element
-->
<xs:attributeGroup name="rb.attlist">
<xs:attributeGroup ref="ruby.common.attrib"/>
</xs:attributeGroup>
<xs:group name="rb.content">
<xs:sequence>
<xs:group ref="InlNoRuby.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="rb.type" mixed="true">
<xs:group ref="rb.content"/>
<xs:attributeGroup ref="rb.attlist"/>
</xs:complexType>
<xs:element name="rb" type="rb.type"/>
<!--
rt (ruby text) element
-->
<xs:attributeGroup name="rt.attlist">
<xs:attributeGroup ref="ruby.common.attrib"/>
<xs:attribute name="rbspan" type="Number" default="1"/>
</xs:attributeGroup>
<xs:group name="rt.content">
<xs:sequence>
<xs:group ref="InlNoRuby.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="rt.type" mixed="true">
<xs:group ref="rt.content"/>
<xs:attributeGroup ref="rt.attlist"/>
</xs:complexType>
<xs:element name="rt" type="rt.type"/>
<!-- rp (ruby parenthesis) element -->
<xs:attributeGroup name="rp.attlist">
<xs:attributeGroup ref="ruby.common.attrib"/>
</xs:attributeGroup>
<xs:group name="rp.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="rp.type" mixed="true">
<xs:group ref="rp.content"/>
<xs:attributeGroup ref="rp.attlist"/>
</xs:complexType>
<xs:element name="rp" type="rp.type"/>
</xs:schema>
C.4. XHTML Schema Support Modules
The modules in this section are elements of the XHTML Schema implementation that, while hidden from casual users, are important to understand when creating derivative markup languages using the
Modularization architecture.
C.4.1. Block Phrasal
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Block Phrasal elements module
This is the XML Schema block phrasal element module for XHTML
* address, blockquote, pre, h1, h2, h3, h4, h5, h6
This module declares the elements and their attributes used to
support block-level phrasal markup.
$Id: xhtml-blkphras-1.xsd,v 1.3 2003/09/23 20:33:11 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<!-- address -->
<xs:attributeGroup name="address.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="address.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="address.type" mixed="true">
<xs:group ref="address.content"/>
<xs:attributeGroup ref="address.attlist"/>
</xs:complexType>
<xs:element name="address" type="address.type"/>
<!-- blockquote -->
<xs:attributeGroup name="blockquote.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="cite" type="URI"/>
</xs:attributeGroup>
<xs:group name="blockquote.content">
<xs:sequence>
<xs:group ref="Block.mix" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="blockquote.type">
<xs:group ref="blockquote.content"/>
<xs:attributeGroup ref="blockquote.attlist"/>
</xs:complexType>
<xs:element name="blockquote" type="blockquote.type"/>
<!-- pre -->
<xs:attributeGroup name="pre.attlist">
<xs:attribute ref="xml:space" fixed="preserve"/>
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="pre.content">
<xs:sequence>
<xs:group ref="InlinePre.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="pre.type" mixed="true">
<xs:group ref="pre.content"/>
<xs:attributeGroup ref="pre.attlist"/>
</xs:complexType>
<xs:element name="pre" type="pre.type"/>
<!-- Heading Elements -->
<xs:attributeGroup name="heading.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:complexType name="heading.type" mixed="true">
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
<xs:attributeGroup ref="heading.attlist"/>
</xs:complexType>
<xs:attributeGroup name="h1.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="h1.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="h1.type" mixed="true">
<xs:group ref="h1.content"/>
<xs:attributeGroup ref="h1.attlist"/>
</xs:complexType>
<xs:element name="h1" type="h1.type"/>
<xs:attributeGroup name="h2.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="h2.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="h2.type" mixed="true">
<xs:group ref="h2.content"/>
<xs:attributeGroup ref="h2.attlist"/>
</xs:complexType>
<xs:element name="h2" type="h2.type"/>
<xs:attributeGroup name="h3.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="h3.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="h3.type" mixed="true">
<xs:group ref="h3.content"/>
<xs:attributeGroup ref="h3.attlist"/>
</xs:complexType>
<xs:element name="h3" type="h3.type"/>
<xs:attributeGroup name="h4.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="h4.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="h4.type" mixed="true">
<xs:group ref="h4.content"/>
<xs:attributeGroup ref="h4.attlist"/>
</xs:complexType>
<xs:element name="h4" type="h4.type"/>
<xs:attributeGroup name="h5.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="h5.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="h5.type" mixed="true">
<xs:group ref="h5.content"/>
<xs:attributeGroup ref="h5.attlist"/>
</xs:complexType>
<xs:element name="h5" type="h5.type"/>
<xs:attributeGroup name="h6.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="h6.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="h6.type" mixed="true">
<xs:group ref="h6.content"/>
<xs:attributeGroup ref="h6.attlist"/>
</xs:complexType>
<xs:element name="h6" type="h6.type"/>
</xs:schema>
C.4.2. Block Presentational
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML SchemaBlock presentation element module for XHTML
$Id: xhtml-blkpres-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Block Presentational Elements
* hr
This module declares the elements and their attributes used to
support block-level presentational markup.
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_presentationmodule"/>
</xs:annotation>
<xs:attributeGroup name="hr.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="hr.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="hr.type">
<xs:group ref="hr.content"/>
<xs:attributeGroup ref="hr.attlist"/>
</xs:complexType>
<xs:element name="hr" type="hr.type"/>
</xs:schema>
C.4.3. Block Structural
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Block Structural
* div, p
This module declares the elements and their attributes used to
support block-level structural markup.
This is the XML Schema Block Structural module for XHTML
$Id: xhtml-blkstruct-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<!-- div -->
<xs:attributeGroup name="div.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="div.content">
<xs:sequence>
<xs:group ref="Flow.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="div.type" mixed="true">
<xs:group ref="div.content"/>
<xs:attributeGroup ref="div.attlist"/>
</xs:complexType>
<xs:element name="div" type="div.type"/>
<!-- p -->
<xs:attributeGroup name="p.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="p.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="p.type" mixed="true">
<xs:group ref="p.content"/>
<xs:attributeGroup ref="p.attlist"/>
</xs:complexType>
<xs:element name="p" type="p.type"/>
</xs:schema>
C.4.4. Inline Phrasal
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Inline Phrasal
This is the XML Schema Inline Phrasal module for XHTML
* abbr, acronym, cite, code, dfn, em, kbd, q, samp, strong, var
This module declares the elements and their attributes used to
support inline-level phrasal markup.
$Id: xhtml-inlphras-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:attributeGroup name="abbr.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="abbr.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="abbr.type" mixed="true">
<xs:group ref="abbr.content"/>
<xs:attributeGroup ref="abbr.attlist"/>
</xs:complexType>
<xs:element name="abbr" type="abbr.type"/>
<xs:attributeGroup name="acronym.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="acronym.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="acronym.type" mixed="true">
<xs:group ref="acronym.content"/>
<xs:attributeGroup ref="acronym.attlist"/>
</xs:complexType>
<xs:element name="acronym" type="acronym.type"/>
<xs:attributeGroup name="cite.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="cite.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="cite.type" mixed="true">
<xs:group ref="cite.content"/>
<xs:attributeGroup ref="cite.attlist"/>
</xs:complexType>
<xs:element name="cite" type="dfn.type"/>
<xs:attributeGroup name="code.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="code.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="code.type" mixed="true">
<xs:group ref="code.content"/>
<xs:attributeGroup ref="code.attlist"/>
</xs:complexType>
<xs:element name="code" type="dfn.type"/>
<xs:attributeGroup name="dfn.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="dfn.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="dfn.type" mixed="true">
<xs:group ref="dfn.content"/>
<xs:attributeGroup ref="dfn.attlist"/>
</xs:complexType>
<xs:element name="dfn" type="dfn.type"/>
<xs:attributeGroup name="em.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="em.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="em.type" mixed="true">
<xs:group ref="em.content"/>
<xs:attributeGroup ref="em.attlist"/>
</xs:complexType>
<xs:element name="em" type="em.type"/>
<xs:attributeGroup name="kbd.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="kbd.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="kbd.type" mixed="true">
<xs:group ref="kbd.content"/>
<xs:attributeGroup ref="kbd.attlist"/>
</xs:complexType>
<xs:element name="kbd" type="kbd.type"/>
<xs:attributeGroup name="samp.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="samp.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="samp.type" mixed="true">
<xs:group ref="samp.content"/>
<xs:attributeGroup ref="samp.attlist"/>
</xs:complexType>
<xs:element name="samp" type="samp.type"/>
<xs:attributeGroup name="strong.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="strong.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="strong.type" mixed="true">
<xs:group ref="strong.content"/>
<xs:attributeGroup ref="strong.attlist"/>
</xs:complexType>
<xs:element name="strong" type="strong.type"/>
<xs:attributeGroup name="var.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="var.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="var.type" mixed="true">
<xs:group ref="var.content"/>
<xs:attributeGroup ref="var.attlist"/>
</xs:complexType>
<xs:element name="var" type="var.type"/>
<xs:attributeGroup name="q.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="cite" type="URI"/>
</xs:attributeGroup>
<xs:group name="q.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="q.type" mixed="true">
<xs:group ref="q.content"/>
<xs:attributeGroup ref="q.attlist"/>
</xs:complexType>
<xs:element name="q" type="q.type"/>
</xs:schema>
C.4.5. Inline Presentational
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Inline Presentation element module for XHTML
$Id: xhtml-inlpres-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Inline Presentational Elements
* b, big, i, small, sub, sup, tt
This module declares the elements and their attributes used to
support inline-level presentational markup.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_presentationmodule"/>
</xs:annotation>
<xs:attributeGroup name="InlPres.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="InlPres.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="InlPres.type" mixed="true">
<xs:group ref="InlPres.content"/>
<xs:attributeGroup ref="InlPres.attlist"/>
</xs:complexType>
<xs:element name="b" type="InlPres.type"/>
<xs:element name="big" type="InlPres.type"/>
<xs:element name="i" type="InlPres.type"/>
<xs:element name="small" type="InlPres.type"/>
<xs:element name="sub" type="InlPres.type"/>
<xs:element name="sup" type="InlPres.type"/>
<xs:element name="tt" type="InlPres.type"/>
</xs:schema>
C.4.6. Inline Structural
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.w3.org/1999/xhtml"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
Inline Structural
This is the XML Schema Inline Structural element module for XHTML
* br, span
This module declares the elements and their attributes
used to support inline-level structural markup.
$Id: xhtml-inlstruct-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:attributeGroup name="br.attlist">
<xs:attributeGroup ref="Core.attrib"/>
</xs:attributeGroup>
<xs:group name="br.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="br.type">
<xs:group ref="br.content"/>
<xs:attributeGroup ref="br.attlist"/>
</xs:complexType>
<xs:element name="br" type="br.type"/>
<xs:attributeGroup name="span.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="span.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="span.type" mixed="true">
<xs:group ref="span.content"/>
<xs:attributeGroup ref="span.attlist"/>
</xs:complexType>
<xs:element name="span" type="span.type"/>
</xs:schema>
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Param Element module for XHTML
$Id: xhtml-param-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
Parameters for Java Applets and Embedded Objects
* param
This module provides declarations for the param element,
used to provide named property values for the applet
and object elements.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_objectmodule"/>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_appletmodule"/>
</xs:annotation>
<xs:attributeGroup name="param.attlist">
<xs:attributeGroup ref="id"/>
<xs:attribute name="name" type="CDATA" use="required"/>
<xs:attribute name="value" type="CDATA"/>
<xs:attribute name="valuetype" default="data">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="data"/>
<xs:enumeration value="ref"/>
<xs:enumeration value="object"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="type" type="ContentType"/>
</xs:attributeGroup>
<xs:group name="param.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="param.type" mixed="true">
<xs:group ref="param.content"/>
<xs:attributeGroup ref="param.attlist"/>
</xs:complexType>
<xs:element name="param" type="param.type"/>
</xs:schema>
C.4.8. Legacy - Miscellaneous
<?xml version="1.0" encoding="UTF-8"?>
<xs:schema targetNamespace="http://www.w3.org/1999/xhtml"
xmlns:xs="http://www.w3.org/2001/XMLSchema"
xmlns="http://www.w3.org/1999/xhtml">
<xs:annotation>
<xs:documentation>
This is the XML Schema Miscellaneous Legacy
Markup module for XHTML
$Id: xhtml-misc-1.xsd,v 1.2 2003/09/20 01:41:37 speruvem Exp $
</xs:documentation>
<xs:documentation source="xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
XHTML Miscellaneous Legacy Markup
font, basefont, center, s, strike, u,
dir, menu, isindex
This is to allow XHTML documents to be transformed for
display on HTML browsers where CSS support is inconsistent
or unavailable.
The module also declares legacy attributes for elements
in other module. Note: This module only declares the
attribute list, and it upto the document type to
redefine the model of affected modules.
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410/abstract_modules.html#s_legacymodule"/>
</xs:annotation>
<xs:attributeGroup name="font.attlist">
<xs:attributeGroup ref="Core.attrib"/>
<xs:attributeGroup ref="I18n.attrib"/>
<xs:attribute name="size" type="CDATA"/>
<xs:attribute name="color" type="Color"/>
<xs:attribute name="face" type="CDATA"/>
</xs:attributeGroup>
<xs:group name="font.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="font.type" mixed="true">
<xs:group ref="font.content"/>
<xs:attributeGroup ref="font.attlist"/>
</xs:complexType>
<xs:element name="font" type="font.type"/>
<xs:attributeGroup name="basefont.attlist">
<xs:attributeGroup ref="id"/>
<xs:attribute name="size" type="CDATA" use="required"/>
<xs:attribute name="color" type="Color"/>
<xs:attribute name="face" type="CDATA"/>
</xs:attributeGroup>
<xs:group name="basefont.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="basefont.type">
<xs:group ref="basefont.content"/>
<xs:attributeGroup ref="basefont.attlist"/>
</xs:complexType>
<xs:element name="basefont" type="basefont.type"/>
<xs:attributeGroup name="center.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="center.content">
<xs:sequence>
<xs:group ref="Flow.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="center.type" mixed="true">
<xs:group ref="center.content"/>
<xs:attributeGroup ref="center.attlist"/>
</xs:complexType>
<xs:element name="center" type="center.type"/>
<xs:attributeGroup name="s.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="s.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="s.type" mixed="true">
<xs:group ref="s.content"/>
<xs:attributeGroup ref="s.attlist"/>
</xs:complexType>
<xs:element name="s" type="s.type"/>
<xs:attributeGroup name="strike.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="strike.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="strike.type" mixed="true">
<xs:group ref="strike.content"/>
<xs:attributeGroup ref="strike.attlist"/>
</xs:complexType>
<xs:element name="strike" type="strike.type"/>
<xs:attributeGroup name="u.attlist">
<xs:attributeGroup ref="Common.attrib"/>
</xs:attributeGroup>
<xs:group name="u.content">
<xs:sequence>
<xs:group ref="Inline.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="u.type" mixed="true">
<xs:group ref="u.content"/>
<xs:attributeGroup ref="u.attlist"/>
</xs:complexType>
<xs:element name="u" type="u.type"/>
<xs:attributeGroup name="dir.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="compact">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="compact"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:group name="dir.content">
<xs:sequence>
<xs:element ref="li" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="dir.type" mixed="true">
<xs:group ref="dir.content"/>
<xs:attributeGroup ref="dir.attlist"/>
</xs:complexType>
<xs:element name="dir" type="dir.type"/>
<xs:attributeGroup name="menu.attlist">
<xs:attributeGroup ref="Common.attrib"/>
<xs:attribute name="compact">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="compact"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:group name="menu.content">
<xs:sequence>
<xs:element ref="li" maxOccurs="unbounded"/>
</xs:sequence>
</xs:group>
<xs:complexType name="menu.type" mixed="true">
<xs:group ref="menu.content"/>
<xs:attributeGroup ref="menu.attlist"/>
</xs:complexType>
<xs:element name="" type="menu.type"/>
<xs:attributeGroup name="isindex.attlist">
<xs:attributeGroup ref="Core.attrib"/>
<xs:attributeGroup ref="I18n.attrib"/>
<xs:attribute name="prompt" type="Text"/>
</xs:attributeGroup>
<xs:group name="isindex.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="isindex.type">
<xs:group ref="isindex.content"/>
<xs:attributeGroup ref="isindex.attlist"/>
</xs:complexType>
<xs:element name="isindex" type="isindex.type"/>
<xs:annotation>
<xs:documentation>
Attribute redefinitions
</xs:documentation>
</xs:annotation>
<xs:attributeGroup name="align.legacy.attlist">
<xs:attribute name="align">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="left"/>
<xs:enumeration value="center"/>
<xs:enumeration value="right"/>
<xs:enumeration value="justify"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<!-- add 'target' attribute to 'a' element -->
<xs:attributeGroup name="a.legacy.attlist">
<xs:attribute name="target" type="FrameTarget"/>
</xs:attributeGroup>
<xs:attributeGroup name="applet.legacy.attlist">
<xs:attribute name="align">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="top"/>
<xs:enumeration value="middle"/>
<xs:enumeration value="bottom"/>
<xs:enumeration value="left"/>
<xs:enumeration value="right"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="hspace" type="Pixels"/>
<xs:attribute name="vspace" type="Pixels"/>
</xs:attributeGroup>
<xs:attributeGroup name="body.legacy.attlist">
<xs:attribute name="background" type="URI"/>
<xs:attribute name="bgcolor" type="Color"/>
<xs:attribute name="text" type="Color"/>
<xs:attribute name="link" type="Color"/>
<xs:attribute name="vlinke" type="Color"/>
<xs:attribute name="alink" type="Color"/>
</xs:attributeGroup>
<xs:attributeGroup name="br.legacy.attlist">
<xs:attribute name="clear" default="none">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="left"/>
<xs:enumeration value="all"/>
<xs:enumeration value="right"/>
<xs:enumeration value="none"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="caption.legacy.attlist">
<xs:attributeGroup ref="align.legacy.attlist"/>
</xs:attributeGroup>
<xs:attributeGroup name="hr.legacy.attlist">
<xs:attribute name="align">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="left"/>
<xs:enumeration value="center"/>
<xs:enumeration value="right"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="noshade">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="noshade"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="size" type="Pixels"/>
<xs:attribute name="width" type="Length"/>
</xs:attributeGroup>
<xs:attributeGroup name="img.legacy.attlist">
<xs:attribute name="align">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="top"/>
<xs:enumeration value="middle"/>
<xs:enumeration value="bottom"/>
<xs:enumeration value="left"/>
<xs:enumeration value="right"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="border" type="Pixels"/>
<xs:attribute name="hspace" type="Pixels"/>
<xs:attribute name="vspace" type="Pixels"/>
</xs:attributeGroup>
<xs:attributeGroup name="input.legacy.attlist">
<xs:attribute name="align">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="top"/>
<xs:enumeration value="middle"/>
<xs:enumeration value="bottom"/>
<xs:enumeration value="left"/>
<xs:enumeration value="right"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="legend.legacy.attlist">
<xs:attribute name="align">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="top"/>
<xs:enumeration value="bottom"/>
<xs:enumeration value="left"/>
<xs:enumeration value="right"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="li.legacy.attlist">
<xs:attribute name="type" type="CDATA"/>
<xs:attribute name="value" type="Number"/>
</xs:attributeGroup>
<xs:attributeGroup name="object.legacy.attlist">
<xs:attribute name="align">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="top"/>
<xs:enumeration value="middle"/>
<xs:enumeration value="bottom"/>
<xs:enumeration value="left"/>
<xs:enumeration value="right"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="border" type="Pixels"/>
<xs:attribute name="hspace" type="Pixels"/>
<xs:attribute name="vspace" type="Pixels"/>
</xs:attributeGroup>
<xs:attributeGroup name="ol.legacy.attlist">
<xs:attribute name="type" type="Text"/>
<xs:attribute name="compact">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="compact"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="start" type="Number"/>
</xs:attributeGroup>
<xs:attributeGroup name="dl.legacy.attlist">
<xs:attribute name="compact">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="compact"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
<xs:attributeGroup name="div.legacy.attlist">
<xs:attributeGroup ref="align.legacy.attlist"/>
</xs:attributeGroup>
<xs:attributeGroup name="heading.legacy.attlist">
<xs:attributeGroup ref="align.legacy.attlist"/>
</xs:attributeGroup>
<xs:attributeGroup name="p.legacy.attlist">
<xs:attributeGroup ref="align.legacy.attlist"/>
</xs:attributeGroup>
<xs:attributeGroup name="pre.legacy.attlist">
<xs:attribute name="width" type="Length"/>
</xs:attributeGroup>
<xs:attributeGroup name="script.legacy.attlist">
<xs:attribute name="language" type="ContentType"/>
</xs:attributeGroup>
<xs:attributeGroup name="table.legacy.attlist">
<xs:attribute name="align">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="left"/>
<xs:enumeration value="center"/>
<xs:enumeration value="right"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="bgcolor" type="Color"/>
</xs:attributeGroup>
<xs:attributeGroup name="tr.legacy.attlist">
<xs:attribute name="bgcolor" type="Color"/>
</xs:attributeGroup>
<xs:attributeGroup name="th.legacy.attlist">
<xs:attribute name="nowrap">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="nowrap"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="bgcolor" type="Color"/>
<xs:attribute name="width" type="Length"/>
<xs:attribute name="height" type="Length"/>
</xs:attributeGroup>
<xs:attributeGroup name="td.legacy.attlist">
<xs:attribute name="nowrap">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="nowrap"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
<xs:attribute name="bgcolor" type="Color"/>
<xs:attribute name="width" type="Length"/>
<xs:attribute name="height" type="Length"/>
</xs:attributeGroup>
<xs:attributeGroup name="ul.legacy.attlist">
<xs:attribute name="type" type="CDATA"/>
<xs:attribute name="compact">
<xs:simpleType>
<xs:restriction base="xs:NMTOKEN">
<xs:enumeration value="compact"/>
</xs:restriction>
</xs:simpleType>
</xs:attribute>
</xs:attributeGroup>
</xs:schema>
D. References
This appendix is normative.
D.1. Normative References
- [CSS2]
- "Cascading Style Sheets, level 2 (CSS2) Specification", W3C Recommendation, B. Bos, H. W. Lie, C. Lilley, I. Jacobs,
eds., 12 May 1998.
Available at: http://www.w3.org/TR/1998/REC-CSS2-19980512
- [DOM]
- "Document Object Model (DOM) Level 1 Specification", L. Wood et al., 1 October
1998.
Available at: http://www.w3.org/TR/1998/REC-DOM-Level-1-19981001
- [HTML4]
- "HTML 4.01 Specification: W3C Recommendation", W3C Recommendation, D. Raggett, A. Le Hors, I. Jacobs, eds., 24
December 1999.
Available at: http://www.w3.org/TR/1999/REC-html401-19991224
- [ISO10646]
- "Information Technology -- Universal Multiple-Octet Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane", ISO/IEC 10646-1:2000. This reference refers to a
set of codepoints that may evolve as new characters are assigned to them. Also, this reference assumes that the character sets defined by ISO 10646 and
[UNICODE] remain character-by-character equivalent. This reference also includes future publications of other parts of 10646 (i.e., other than Part 1) that define characters in planes 1-16.
- [RUBY]
- Ruby Annotation, M. Sawicki et al., 31 May 2001
Available at: http://www.w3.org/TR/2001/REC-ruby-20010531
- [RFC1808]
- "Relative Uniform Resource Locators", RFC 1808, R. Fielding, June 1995.
Available at: http://www.ietf.org/rfc/rfc1808.txt
- [RFC2045]
- "Multipurpose Internet Mail Extensions (MIME) Part One: Format of Internet Message Bodies", RFC 2045, N. Freed, N. Borenstein,
November 1996.
Available at: http://www.ietf.org/rfc/rfc2045.txt
- [RFC2119]
- "Key words for use in RFCs to indicate requirement levels", RFC 2119, S. Bradner, March 1997.
Available at: http://www.ietf.org/rfc/rfc2119.txt
- [RFC3066]
- "Tags for the Identification of Languages", RFC 3066, H. Alvestrand, January 2001.
Available at: http://www.ietf.org/rfc/rfc3066.txt
- [SRGB]
- "A Standard Default Color Space for the Internet", version 1.10, M. Stokes, M. Anderson, S. Chandrasekar, and R. Motta, 5 November
1996. Available at: http://www.w3.org/Graphics/Color/sRGB
- [UNICODE]
- "The Unicode Standard", The Unicode Consortium. Version 3.1 of the Unicode Standard is composed of a book documenting version 3.0 and an online Unicode Standard Annex documenting the
changes and additions that make up version 3.1.
"The Unicode Standard -- Version 3.0", The Unicode Consortium, Reading, Mass.: Addison-Wesley Developers Press, 2000. ISBN
0-201-61633-5 (see http://www.unicode.org/unicode/uni2book/u2.html for the online edition of the book).
"Unicode Standard Annex #27 -- Unicode 3.1", Mark Davis, Michael Everson, Asmus Freytag, John H. Jenkins et al. (see
http://www.unicode.org/unicode/reports/tr27/).
For more information about Unicode, see http://www.unicode.org.
- [URI]
- "Uniform Resource Identifiers (URI): Generic Syntax", RFC 2396, T. Berners-Lee, R. Fielding, L. Masinter, August 1998.
Available at: http://www.ietf.org/rfc/rfc2396.txt. This RFC updates RFC 1738 [URL] and [RFC1808].
- [URL]
- "Uniform Resource Locators (URL)", RFC 1738, T. Berners-Lee, L. Masinter, M. McCahill, December 1994.
Available at: http://www.ietf.org/rfc/rfc1738.txt
- [XHTML1]
- "XHTML 1.0: The Extensible HyperText Markup Language", W3C Recommendation, S. Pemberton et
al., 26 January 2000.
Available at: http://www.w3.org/TR/2000/REC-xhtml1-20000126
- [XHTMLMOD]
- Modularization of XHTML, W3C Recommendation, M. Altheim, et al., 10 April 2001
Available at: http://www.w3.org/TR/2001/REC-xhtml-modularization-20010410
- [XML]
- Extensible Markup Language (XML) 1.0 (Second Edition), W3C Recommendation, T. Bray et al., 6 October 2000.
Available at: http://www.w3.org/TR/2000/REC-xml-20001006
- [XMLNAMES]
- Namespaces in XML, W3C Recommendation, T. Bray et al., 14 January 1999.
Available at: http://www.w3.org/TR/1999/REC-xml-names-19990114
- [XMLSCHEMA]
- "XML Schema Part 1: Structures", W3C Proposed Recommendation, H. S. Thompson, D. Beech, M. Maloney, N. Mendelsohn,
eds., 30 March 2001.
Available at: http://www.w3.org/TR/2001/PR-xmlschema-1-20010330
See also "XML Schema Part 2: Datatypes", available at: http://www.w3.org/TR/2001/PR-xmlschema-2-20010330
See also "XML XML Schema Part 0: Primer", available at: http://www.w3.org/TR/2001/PR-xmlschema-0-20010330
D.2. Informative References
- [APPROACH]
- An Approach to the Modularization of XHTML using XML Schema, R. Jelliffe, Academia Sinica Computing Center, 19 December 2000.
Available at: http://www.ascc.net/~ricko/xhtml.htm
- [MathML]
- Mathematical Markup Language (MathML) Version 2.0, D. Carlisle et al., 21 February 2001.
Available at: http://www.w3.org/TR/2001/REC-MathML2-20010221
- [SMIL]
- SMIL 2.0: Synchronized Multimedia Integration Language (SMIL 2.0), W3C Recommendation, Jeff Ayars, et al., 07
August 2001.
Available at: http://www.w3.org/TR/2001/REC-smil20-20010807
E. Acknowledgements
This appendix is informative.
The following people provided support and assistance:
- Henry Thompson
- C. M. Sperberg-McQueen
- The XML Schema Working Group
- Peter Stark
- Steven Pemberton
- Rick Jelliffe
- Josef Dietl
- Sebastian Schnitzenbaumer
- Malte Wedel
- Jack Herer