# B. Developing Schema with defined and extended modules

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.

## 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 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).

## 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 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.

## 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:

1. Re-define the named content model, `.content`, for each element.
2. 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:

1. Decide what element(s) can be thought of as the root(s) of the new module.
2. Decide where these elements need to attach in the XHTML content tree.
3. 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-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`.

### 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.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.

## 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.4 2005/04/25 18:53:05 ahby 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>
          <xs:element ref="otherelement" minOccurs="0" maxOccurs="unbounded"/>
        </xs:choice>
      </xs:group>

      <xs:attributeGroup name="element.attlist">
        <xs:attributeGroup ref="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:

    <?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.4 2005/04/25 18:53:05 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="Misc.class">
          <xs:choice>
            <xs:group ref="Misc.class"/>
            <xs:element ref="simpleml:element"/>
          </xs:choice>
        </xs:group>

        <xs:attributeGroup name="img.attlist">
           <xs:attributeGroup ref="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:

    <?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>

### 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 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 :

    <?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):

    <?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>

### 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 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:

1. Take an XHTML family Schema as the basis of the new document type (e.g. XHTML 1.1).
2. Select the modules to remove from that Schema.
3. Physically, remove `include` and `redefine` schema elements that include any non relevant modules from the driver file. Also references to schema components from such modules used in redefinitions of other modules must be deleted.
4. 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 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: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:

    <?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.

    <?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)

    <?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 &#169;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:

    <?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>