Contents
This appendix 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 using XML Schemas. 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.
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 would create a Global attribute (and document instances would have to use qualified attribute name 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 (by the document type's driver file) to include the new attribute. for example:
<xs:redefine schemaLocation="xhtml-basic10.xsd">
<xs:attributeGroup name="a.attlist">
<xs:attributeGroup ref="a.attlist"/>
<xs:attributeGroup ref="myml:myattrs.attrib"/>
</xs:attributeGroup>
</xs:redefine>
The target namespace of the attribute group definition is not XHTML namespace and must be contained in a separate XML schema.
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).
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 provide the element declaration for each element:
<!-- In the myml-module-1.xsd -->
<xs:group name="myelement.content">
<xs:choice>
<xs:element name="otherelement"/>
</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 target namespace of "myelement" declared is not XHTML namespace, hence must be contained in a separate XML Schema. "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.
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:
.content, for each element..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.
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:
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-basic10.xsd">
<xs:group name="img.content">
<xs:choice>
<xs:group ref="img.content"/>
<xs:element ref="myml:myelement"/>
</xs:choice>
</xs:group>
</xs:redefine>
Such redefinition must not be included in the module implementation, but instead provided as part of the document type's driver implementation. A schema defined with this content model would allow a document like the following fragment:
<img src="http://examples.com/image" alt="alt-text"> <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.
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.xsd">
<xs:group name="Misc.extra">
<xs:choice>
<xs:group ref="Misc.extra"/>
<xs:element ref="myml: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.
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.
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:
You can download this version of this file from http://www.w3.org/TR/2010/REC-xhtml-modularization/SCHEMA/examples/simpleml-module-1.xsd. The latest version is available at http://www.w3.org/MarkUp/SCHEMA/examples/simpleml-module-1.xsd.
<?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.5 2006/06/12 22:38:55 ahby Exp $
</xs:documentation>
<xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:attributeGroup name="xhtml.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="xhtml.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>
<xs:element ref="otherelement" minOccurs="0" maxOccurs="unbounded"/>
</xs:choice>
</xs:group>
<xs:attributeGroup name="element.attlist">
<xs:attributeGroup ref="xhtml.Common.attrib"/>
</xs:attributeGroup>
<xs:complexType name="element.type" mixed="true">
<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 driver for the new language:
You can download this version of this file from http://www.w3.org/TR/2010/REC-xhtml-modularization/SCHEMA/examples/simpleml-1_0.xsd. The latest version is available at http://www.w3.org/MarkUp/SCHEMA/examples/simpleml-1_0.xsd.
<?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:simpleml="http://www.example.com/xmlns/simpleml1"
xmlns="http://www.w3.org/1999/xhtml"
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.5 2006/06/12 22:38:55 ahby Exp $
</xs:documentation>
<xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:import namespace="http://www.example.com/xmlns/simpleml1"
schemaLocation="simpleml-module-1.xsd"/>
<xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-basic10.xsd">
<xs:group name="xhtml.Misc.class">
<xs:choice>
<xs:group ref="xhtml.Misc.class"/>
<xs:element ref="simpleml:element"/>
</xs:choice>
</xs:group>
<xs:attributeGroup name="xhtml.img.attlist">
<xs:attributeGroup ref="xhtml.img.attlist"/>
<xs:attribute ref="simpleml:myattr"/>
</xs:attributeGroup>
</xs:redefine>
</xs:schema>
A schema defined with this content model would allow a document like the following:
You can download this version of this file from http://www.w3.org/TR/2010/REC-xhtml-modularization/SCHEMA/examples/simple-prefixed.html. The latest version is available at http://www.w3.org/MarkUp/SCHEMA/examples/simple-prefixed.html.
<?xml version="1.0" encoding="UTF-8"?>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:simpleml="http://www.example.com/xmlns/simpleml1"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.w3.org/1999/xhtml simpleml-1_0.xsd">
<head>
<title>An example using defaults</title>
</head>
<body>
<p>This is content in the XHTML namespace</p>
<simpleml:element>
This is content in the SimpleML namespace.
<simpleml:otherelement/>
</simpleml:element>
<p>
<img src="missing" alt="Missing image" simpleml:myattr="value"/>
</p>
</body>
</html>
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 creating an new document model 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 redefinition of the XHTML content model by implication includes the XHTML content model in the new document content model :
You can download this version of this file from http://www.w3.org/TR/2010/REC-xhtml-modularization/SCHEMA/examples/mathml-model-1.xsd. The latest version is available at http://www.w3.org/MarkUp/SCHEMA/examples/mathml-model-1.xsd.
<?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:math="http://www.w3.org/1998/Math/MathML">
<xs:import namespace="http://www.w3.org/1998/Math/MathML"/>
<xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml11-model-1.xsd">
<xs:group name="xhtml.InlSpecial.class">
<xs:choice>
<xs:group ref="xhtml.InlSpecial.class"/>
<xs:element ref="math:math"/>
</xs:choice>
</xs:group>
</xs:redefine>
</xs:schema>
Next, define a Schema driver that includes our new document content model with XHTML1.1 modules and MathML module (for example):
You can download this version of this file from http://www.w3.org/TR/2010/REC-xhtml-modularization/SCHEMA/examples/xhtml-mathml.xsd. The latest version is available at http://www.w3.org/MarkUp/SCHEMA/examples/xhtml-mathml.xsd.
<?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:simpleml="http://www.example.com/xmlns/simpleml1"
xmlns="http://www.w3.org/1999/xhtml"
blockDefault="#all">
<xs:import namespace="http://www.w3.org/XML/1998/namespace"
schemaLocation="http://www.w3.org/2001/xml.xsd"/>
<xs:import namespace="http://www.w3.org/1998/Math/MathML"
schemaLocation="http://www.w3.org/Math/XMLSchema/mathml2/mathml2.xsd"/>
<xs:include schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml11-modules-1.xsd"/>
<xs:include schemaLocation="mathml-model-1.xsd"/>
</xs:schema>
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 model of 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:
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 provided template.
You can download this version of this file from http://www.w3.org/TR/2010/REC-xhtml-modularization/SCHEMA/examples/myml-module-1.xsd. The latest version is available at http://www.w3.org/MarkUp/SCHEMA/examples/myml-module-1.xsd.
<?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:xhtml="http://www.w3.org/1999/xhtml"
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.4 2005/10/20 14:14:40 ahby 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:import namespace="http://www.w3.org/1999/xhtml"/>
<xs:attributeGroup name="myml.myotherelement.attlist">
<xs:attributeGroup ref="xhtml:xhtml.Global.common.attrib"/>
</xs:attributeGroup>
<xs:group name="myml.myotherelement.content">
<xs:sequence/>
</xs:group>
<xs:complexType name="myml.myotherelement.type">
<xs:group ref="myml.myotherelement.content"/>
<xs:attributeGroup ref="myml.myotherelement.attlist"/>
</xs:complexType>
<xs:element name="myotherelement" type="myml.myotherelement.type"/>
<xs:group name="myml.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 ref="xhtml:Global.common.attrib"/>
</xs:attributeGroup>
<xs:complexType name="myml.myelement.type" mixed="true">
<xs:choice>
<xs:group ref="myml.myelement.content" minOccurs="0" maxOccurs="1"/>
</xs:choice>
<xs:attributeGroup ref="myml.myelement.attlist"/>
</xs:complexType>
<xs:element name="myelement" type="myml.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:
You can download this version of this file from http://www.w3.org/TR/2010/REC-xhtml-modularization/SCHEMA/examples/myml-model-1.xsd. The latest version is available at http://www.w3.org/MarkUp/SCHEMA/examples/myml-model-1.xsd.
<?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.6 2005/10/20 14:14:40 ahby Exp $
</xs:documentation>
<xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
XHTML + MyML 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:import namespace="http://www.example.com/xmlns/myml"/>
<xs:attributeGroup name="xhtml.I18n.extra.attrib">
<xs:annotation>
<xs:documentation>
Extended I18n attribute
</xs:documentation>
</xs:annotation>
</xs:attributeGroup>
<xs:attributeGroup name="xhtml.Core.extra.attrib">
<xs:annotation>
<xs:documentation>
Extended Core Attributes
</xs:documentation>
</xs:annotation>
</xs:attributeGroup>
<xs:attributeGroup name="xhtml.Common.extra">
<xs:annotation>
<xs:documentation>
Extended Common Attributes
</xs:documentation>
</xs:annotation>
</xs:attributeGroup>
<xs:attributeGroup name="xhtml.Global.core.extra.attrib">
<xs:annotation>
<xs:documentation>
Extended Global Core Attributes
</xs:documentation>
</xs:annotation>
</xs:attributeGroup>
<xs:attributeGroup name="xhtml.Global.I18n.extra.attrib">
<xs:annotation>
<xs:documentation>
Extended Global I18n attributes
</xs:documentation>
</xs:annotation>
</xs:attributeGroup>
<xs:attributeGroup name="xhtml.Global.Common.extra">
<xs:annotation>
<xs:documentation>
Extended Global Common Attributes
</xs:documentation>
</xs:annotation>
</xs:attributeGroup>
<xs:group name="xhtml.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="xhtml.Misc.class">
<xs:choice>
<xs:element ref="myml:myelement"/>
</xs:choice>
</xs:group>
<!-- Inline Elements -->
<xs:group name="xhtml.InlStruct.class">
<xs:choice>
<xs:element ref="br"/>
<xs:element ref="span"/>
</xs:choice>
</xs:group>
<xs:group name="xhtml.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="xhtml.InlPres.class">
<xs:choice/>
</xs:group>
<xs:group name="xhtml.I18n.class">
<xs:sequence/>
</xs:group>
<xs:group name="xhtml.Anchor.class">
<xs:sequence>
<xs:element ref="a"/>
</xs:sequence>
</xs:group>
<xs:group name="xhtml.InlSpecial.class">
<xs:choice>
<xs:element ref="img"/>
<xs:element ref="object"/>
</xs:choice>
</xs:group>
<xs:group name="xhtml.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="xhtml.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="xhtml.Inline.class">
<xs:choice>
<xs:group ref="xhtml.InlStruct.class"/>
<xs:group ref="xhtml.InlPhras.class"/>
<xs:group ref="xhtml.Anchor.class"/>
<xs:group ref="xhtml.InlSpecial.class"/>
<xs:group ref="xhtml.InlForm.class"/>
<xs:group ref="xhtml.Inline.extra"/>
</xs:choice>
</xs:group>
<!--
InlinePre.class
Used as a component in pre model
-->
<xs:group name="xhtml.InlinePre.mix">
<xs:choice>
<xs:group ref="xhtml.InlStruct.class"/>
<xs:group ref="xhtml.InlPhras.class"/>
<xs:group ref="xhtml.Anchor.class"/>
<xs:group ref="xhtml.Inline.extra"/>
</xs:choice>
</xs:group>
<!--
InlNoAnchor.class includes all non-anchor inlines,
used as a component in mixes
-->
<xs:group name="xhtml.InlNoAnchor.class">
<xs:choice>
<xs:group ref="xhtml.InlStruct.class"/>
<xs:group ref="xhtml.InlPhras.class"/>
<xs:group ref="xhtml.InlSpecial.class"/>
<xs:group ref="xhtml.InlForm.class"/>
<xs:group ref="xhtml.Inline.extra"/>
</xs:choice>
</xs:group>
<!--
InlNoAnchor.mix includes all non-anchor inlines
-->
<xs:group name="xhtml.InlNoAnchor.mix">
<xs:choice>
<xs:group ref="xhtml.InlNoAnchor.class"/>
<xs:group ref="xhtml.Misc.class"/>
</xs:choice>
</xs:group>
<!--
Inline.mix includes all inline elements, including Misc.class
-->
<xs:group name="xhtml.Inline.mix">
<xs:choice>
<xs:group ref="xhtml.Inline.class"/>
<xs:group ref="xhtml.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="xhtml.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="xhtml.List.class">
<xs:choice>
<xs:element ref="ul"/>
<xs:element ref="ol"/>
<xs:element ref="dl"/>
</xs:choice>
</xs:group>
<xs:group name="xhtml.Table.class">
<xs:choice>
<xs:element ref="table"/>
</xs:choice>
</xs:group>
<xs:group name="xhtml.Form.class">
<xs:choice>
<xs:element ref="form"/>
</xs:choice>
</xs:group>
<xs:group name="xhtml.BlkStruct.class">
<xs:choice>
<xs:element ref="p"/>
<xs:element ref="div"/>
</xs:choice>
</xs:group>
<xs:group name="xhtml.BlkPhras.class">
<xs:choice>
<xs:element ref="pre"/>
<xs:element ref="blockquote"/>
<xs:element ref="address"/>
</xs:choice>
</xs:group>
<xs:group name="xhtml.BlkPres.class">
<xs:choice/>
</xs:group>
<xs:group name="xhtml.BlkSpecial.class">
<xs:choice>
<xs:group ref="xhtml.Table.class"/>
<xs:group ref="xhtml.Form.class"/>
</xs:choice>
</xs:group>
<xs:group name="xhtml.Block.extra">
<xs:choice/>
</xs:group>
<!--
Block.class includes all block elements,
used as an component in mixes
-->
<xs:group name="xhtml.Block.class">
<xs:choice>
<xs:group ref="xhtml.BlkStruct.class"/>
<xs:group ref="xhtml.BlkPhras.class"/>
<xs:group ref="xhtml.BlkSpecial.class"/>
<xs:group ref="xhtml.Block.extra"/>
</xs:choice>
</xs:group>
<!--
Block.mix includes all block elements plus %Misc.class;
-->
<xs:group name="xhtml.Block.mix">
<xs:choice>
<xs:group ref="xhtml.Heading.class"/>
<xs:group ref="xhtml.List.class"/>
<xs:group ref="xhtml.Block.class"/>
<xs:group ref="xhtml.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="xhtml.Flow.mix">
<xs:choice>
<xs:group ref="xhtml.Heading.class"/>
<xs:group ref="xhtml.List.class"/>
<xs:group ref="xhtml.Block.class"/>
<xs:group ref="xhtml.Inline.class"/>
<xs:group ref="xhtml.Misc.class"/>
</xs:choice>
</xs:group>
<xs:group name="xhtml.FlowNoTable.mix">
<xs:choice>
<xs:group ref="xhtml.Heading.class"/>
<xs:group ref="xhtml.List.class"/>
<xs:group ref="xhtml.BlkStruct.class"/>
<xs:group ref="xhtml.BlkPhras.class"/>
<xs:group ref="xhtml.Form.class"/>
<xs:group ref="xhtml.Inline.class"/>
<xs:group ref="xhtml.Misc.class"/>
</xs:choice>
</xs:group>
<!--
BlkNoForm.mix includes all non-form block elements,
plus Misc.class
-->
<xs:group name="xhtml.BlkNoForm.mix">
<xs:choice>
<xs:group ref="xhtml.Heading.class"/>
<xs:group ref="xhtml.List.class"/>
<xs:group ref="xhtml.BlkStruct.class"/>
<xs:group ref="xhtml.BlkPhras.class"/>
<xs:group ref="xhtml.BlkPres.class"/>
<xs:group ref="xhtml.Table.class"/>
<xs:group ref="xhtml.Misc.class"/>
</xs:choice>
</xs:group>
<xs:element name="html" type="xhtml.html.type"/>
</xs:schema>
Finally, build a driver schema. For ease of extensibility this driver schema is split into two XML Schema files. The first file of driver schema collects (includes) all the modules needed for the new document type. This schema also provides the required redefinitions of schema components in included modules.(Note: in XML Schema redefine includes the schema referenced.
You can download this version of this file from http://www.w3.org/TR/2010/REC-xhtml-modularization/SCHEMA/examples/myml-modules-1.xsd. The latest version is available at http://www.w3.org/MarkUp/SCHEMA/examples/myml-modules-1.xsd.
<?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 schema includes all modules for XHTML Basic 1.0 + MyML
Document Type.
$Id: myml-modules-1.xsd,v 1.3 2004/01/15 06:01:40 speruvem Exp $
</xs:documentation>
<xs:documentation source="http://www.w3.org/MarkUp/SCHEMA/xhtml-copyright-1.xsd"/>
</xs:annotation>
<xs:annotation>
<xs:documentation>
This schema includes (with component redefinitions as required) all
modules for XHTML Basic 1.0 + MyML Document Type
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="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:redefine 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: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:group ref="head.content"/>
<xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
<xs:sequence minOccurs="0">
<xs:element ref="base"/>
<xs:group ref="HeadOpts.mix" minOccurs="0" maxOccurs="unbounded"/>
</xs:sequence>
</xs:sequence>
<xs:sequence>
<xs:element ref="base"/>
<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:choice>
</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: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:documentation
source="http://www.w3.org/TR/xhtml-modularization/abstract_modules.html#s_linkmodule"/>
</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:documentation
source="http://www.w3.org/TR/xhtml-modularization/abstract_modules.html#s_metamodule"/>
</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:documentation
source="http://www.w3.org/TR/xhtml-modularization/abstract_modules.html#s_basemodule"/>
</xs:annotation>
</xs:include>
<xs:redefine schemaLocation="http://www.w3.org/MarkUp/SCHEMA/xhtml-image-1.xsd">
<xs:annotation>
<xs:documentation>
Image module
Elements defined here:
* img
</xs:documentation>
<xs:documentation
source="http://www.w3.org/TR/xhtml-modularization/abstract_modules.html#s_imagemodule"/>
</xs:annotation>
<xs:attributeGroup name="img.attlist">
<xs:attributeGroup ref="img.attlist"/>
<xs:attribute ref="myml:myattr"/>
</xs:attributeGroup>
</xs:redefine>
<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:documentation
source="http://www.w3.org/TR/xhtml-modularization/abstract_modules.html#s_objectmodule"/>
</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:documentation
source="http://www.w3.org/TR/xhtml-modularization/abstract_modules.html#s_sformsmodule"/>
</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:documentation
source="http://www.w3.org/TR/xhtml-modularization/abstract_modules.html#s_simpletablemodule"/>
</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>
The second file of the driver schema builds new document type based the content model and modules. Also this schema provides the schemaLocation for all imported namespaces (namespaces imported by the included modules)
You can download this version of this file from http://www.w3.org/TR/2010/REC-xhtml-modularization/SCHEMA/examples/myml-1_0.xsd. The latest version is available at http://www.w3.org/MarkUp/SCHEMA/examples/myml-1_0.xsd.
<?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"
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.5 2005/04/25 18:53:05 ahby 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-2004 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
+ imports external schemas (xml.xsd)
+ refedines (and include)s schema modules for XHTML
Basic 1.0 + MyML Document Type.
+ includes Schema for Named content model for the
XHTML Basic 1.0 + MyML Document Type
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:import namespace="http://www.w3.org/XML/1998/namespace"
schemaLocation="http://www.w3.org/2001/xml.xsd">
<xs:annotation>
<xs:documentation>
This import brings in the XML namespace attributes
The XML attributes are used by various modules
</xs:documentation>
</xs:annotation>
</xs:import>
<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="myml-modules-1.xsd">
<xs:annotation>
<xs:documentation>
Schema that includes all modules for XHTML Basic 1.0 + MyML
Document Type.
</xs:documentation>
</xs:annotation>
</xs:include>
</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:
You can download this version of this file from http://www.w3.org/TR/2010/REC-xhtml-modularization/SCHEMA/examples/myml-prefixed.html. The latest version is available at http://www.w3.org/MarkUp/SCHEMA/examples/myml-prefixed.html.
<?xml version="1.0" encoding="UTF-8"?>
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:xhtml="http://www.w3.org/1999/xhtml"
xmlns:myml="http://www.example.com/xmlns/myml"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi: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 xhtml:id="myid" xhtml:class="localElement">
This is content in the myml namespace.
<myml:myotherelement/>
</myml:myelement>
<p>
<img src="missing" alt="Missing image" myml:myattr="value"/>
</p>
</body>
</html>