Contents
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.
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).
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.
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-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.
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.
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:
<?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>
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"/>
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:
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>