Lisez-moi S.V.P. 

B. Développement de schémas avec des modules définis et étendus

Sommaire

Cette annexe est informative.

L'objectif premier de la définition des modules XHTML et d'une méthodologie de modularisation générale est de faciliter le développement de types de document fondés sur XHTML en utilisant des schémas XML. Ces types de document peuvent étendre XHTML en intégrant des capacités additionnelles (par exemple [SMIL]), ou peuvent définir un sous-ensemble de XHTML à employer dans un appareil spécialisé. Cette section décrit les techniques que doivent utiliser les concepteurs de types de document afin de profiter de la mise en œuvre XML Schema de cette architecture de modularisation. Les techniques XHTML Modularization y sont appliquées dans des exemples de complexité croissante culminant par la création d'un type de document complet à partir de modules disparates.

Notez que ces exemples ne nécessitent en aucun cas la modification des entités de fichier mêmes des modules XHTML. Les entités de fichier des modules XHTML sont entièrement paramétrées, il est donc possible de personnaliser la définition et le modèle de contenu de chaque élément et chaque hiérarchie d'élément à l'aide de définitions de module séparées et de fichiers pilotes.

Enfin, pensez que la plupart des utilisateurs de XHTML ne sont pas censés être des auteurs de schémas XML. Un auteur de schémas XML est généralement une personne qui définit du balisage spécialisé pour améliorer la lisibilité, simplifier le rendu d'un document ou faciliter le traitement machine des documents, ou c'est un concepteur qui doit définir le langage de balisage spécialisé particulier de son client. Prenons les cas suivants :

B.1. Définition d'attributs supplémentaires

Dans certains cas, une extension de XHTML se réduit simplement à des attributs supplémentaires. Les créateurs de schémas devraient fournir les définitions d'attribut de chacuns. Par exemple :

<xs:attributeGroup name="myattrs.attrib">
    <xs:attribute name="myattribute" type="xs:string"/>
</xs:attributeGroup>

déclarerait l'attribut "myattr" et le groupe d'attributs "myattrs.attrib" dans l'espace de noms cible du schéma ("xs" est le préfixe de l'espace de noms XML Schema). Les auteurs devraient noter que l'attribut est créé en tant qu'attribut local (comme partie d'un groupe d'attributs). Autrement, si on déclarait l'attribut en plaçant sa déclaration en sous-élément direct de l'élément schema, on créerait un attribut global (et les instances de document devraient utiliser un nom d'attribut qualifié tel que xlink:show). Pour une explication des noms qualifiés et des préfixes d'espace de noms, cf. la section Définition de l'espace de noms d'un module.

Pour ajouter cet attribut au modèle de contenu d'un élément, le groupe d'attributs (qui fait le modèle de contenu de l'élément) devrait être redéfini (par le fichier pilote du type de document) afin d'y inclure le nouvel attribut. Par exemple :

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

L'espace de noms cible de la définition du groupe d'attributs, qui n'est pas l'espace de noms XHTML, doit être contenu dans un schéma XML séparé.

Naturellement, ajouter un attribut à un schéma ne veut pas dire que l'on définit un nouveau comportement pour des clients arbitraires. En revanche, un développeur de contenu pourrait utiliser un attribut supplémentaire pour stocker de l'information que, par exemple, des scripts associés récupèreraient via le modèle objet de document (DOM).

B.2. Définition d'éléments supplémentaires

La définition d'éléments supplémentaires est similaire à celle des attributs, mais un module XHTML typique définirait l'élément globalement (comme un sous-élément direct de l'élément schema). Les créateurs de schémas devraient d'abord fournir les déclarations d'élément de chacuns :

<!-- 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"/>

L'espace de noms cible de l'élément "myelement" déclaré, qui n'est pas l'espace de noms de XHTML, doit donc être contenu dans un schéma XML séparé. Le préfixe "xs" est celui de l'espace de nom XML Schema. Une fois les éléments définis, il faut les intégrer au modèle de contenu. Les stratégies d'intégration des nouveaux éléments ou jeux d'éléments au modèle de contenu sont traitées à la section suivante.

B.3. Définition du modèle de contenu d'une collection de modules

Puisque le modèle de contenu des modules XHTML est entièrement paramétré en utilisant des modèles de contenu nommés, les créateurs de schémas peuvent modifier le modèle de contenu de chaque élément dans chaque module. Les détails de l'interface de modules de schéma sont décrits à la section Construction des modules de schéma. Dans l'ensemble, il y a deux façons d'aborder cette modification :

  1. Redéfinir le modèle de contenu nommé .content de chaque élément ;
  2. Définir une ou plusieurs des entités du modèle de contenu nommé global afin d'inclure l'élément dans ces définitions du modèle nommé (normalement via des modèles de contenu nommés .extra).

La stratégie adoptée dépendra de la nature des modules à combiner et de la nature des éléments à intégrer. Le reste de cette section décrit les techniques pour intégrer deux classes différentes de modules.

B.3.1. Intégrer un module autonome dans XHTML

Lorsqu'un module (sachant qu'un module peut être une collection d'autres modules) contient des éléments qui se référencent les uns les autres dans leur modèle de contenu, on dit qu'il est « complet en interne » (internally complete). De ce fait, on peut utiliser le module seul ; par exemple, on pourrait définir un schéma qui est juste ce module, et utiliser un de ses éléments comme étant l'élément racine). L'intégration d'un tel module en XHTML se fait en trois étapes :

  1. Décider quel élément (ou quels éléments) serait susceptible(s) d'être la racine (ou les racines) du nouveau module ;
  2. Décider où doivent s'attacher ces éléments dans l'arbre de contenu XHTML ;
  3. Puis, pour chaque point d'attache dans l'arbre de contenu, ajouter l'élément racine (ou les éléments racines) à la définition de contenu des éléments XHTML.

Supposons que l'on attache les éléments définis précédemment. Dans cet exemple, l'élément myelement est la racine. Pour attacher cet élément sous l'élément img (et seulement l'élément img) de XHTML, cette redéfinition-ci fonctionnerait :

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

Une telle redéfinition ne doit pas être contenue dans la mise en œuvre du module, mais plutôt fournie dans la mise en œuvre du pilote du type de document. Un schéma défini avec ce modèle de contenu accepterait un document tel que le fragment suivant :

<img src="http://examples.com/image" alt="alt-text">
  <myml:myelement >This is content of a locally defined element</myml:myelement>
</img>

Il est important de noter que l'élément img a normalement un modèle de contenu vide (EMPTY). En ajoutant l'élément "myelement" à ce modèle de contenu, nous remplaçons en fait simplement EMPTY par myelement. Pour d'autres éléments qui auraient déjà des modèles de contenu définis, l'ajout d'un élément imposerait la redéclaration du modèle de contenu existant en plus de myelement.

B.3.2. Mélanger un nouveau module partout dans les modules dans XHTML

En prolongement de l'exemple ci-dessus, attacher ce module partout où le groupe de modèle de contenu %Flow.mix est permis exigerait quelque chose comme ce qui suit dans le schéma qui définit le modèle de document du type de document :

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

Puisque la classe de modèle de contenu Misc.extra est utilisée dans le modèle de contenu, le modèle nommé Misc.class, et que le modèle nommé est utilisé partout dans les modules XHTML, le nouveau module sera disponible partout dans un type de document XHTML étendu.

B.4. Création d'un nouveau type de document

Jusqu'ici les exemples de cette section ont décrit les méthodes d'extension de XHTML et du modèle de contenu XHTML. Cela étant fait, l'étape suivante est de collecter les modules qui composent le type de document dans un pilote de schéma et un fichier de schéma qui fournit les redéfinitions de modèle de contenu des modules inclus, en incorporant les nouvelles définitions afin d'outrepasser (override) et augmenter les définitions XHTML de base comme approprié.

B.4.1. Création d'un type de document simple

En utilisant les exemples simples précédents, il est possible de définir assez facilement un nouveau schéma qui utilise et étend les modules XHTML. D'abord, définir les nouveaux éléments et leur modèle de contenu dans un module :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/SCHEMA/examples/simpleml-module-1.xsd. La dernière version est disponible à 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="a_smodule_element_nootherelement" 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="a_smodule_element_noelement" type="element.type"/>
    
  <!-- Note: Global attribute -->
  <xs:attribute name="myattr" type="xs:string"/>

</xs:schema>

Puis définir le pilote de schéma du nouveau langage :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/SCHEMA/examples/simpleml-1_0.xsd. La dernière version est disponible à 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>

Un schéma défini avec ce modèle de contenu admettrait ce document-ci :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/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>

B.4.2. Création d'un langage par extension de XHTML

Ensuite, nous avons la situation où un module complet, supplémentaire et complexe est ajouté à XHTML (ou un sous-ensemble de XHTML). En essence, c'est la même chose que dans l'exemple ci-dessus, les seules différences étant que le module à ajouter est incorporé dans le schéma en créant un nouveau schéma de modèle de document.

Un tel module complexe est le schéma de [MATHML]. Pour combiner MathML et XHTML en un seul schéma, l'auteur devrait juste décider où le contenu MathML serait légal dans le document et ajouter à cet endroit l'élément racine de MathML. D'abord, définir un nouveau modèle de document qui instancie le schéma MathML et le connecte au modèle de contenu XHTML en redéfinissant le modèle de contenu XHTML. Pourvoir une redéfinition du modèle de contenu XHTML par implication inclut le modèle de contenu XHTML dans le nouveau modèle de contenu du document :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/SCHEMA/examples/mathml-model-1.xsd. La dernière version est disponible à 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>

Ensuite, définir un pilote de schéma qui inclut notre nouveau modèle de contenu de document avec les modules XHTML1.1 et le module MathML (par exemple) :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/SCHEMA/examples/xhtml-mathml.xsd. La dernière version est disponible à 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>

B.4.3. Création d'un langage par suppression et remplacement de modules XHTML

Un autre moyen par lequel les créateurs de schémas peuvent utiliser les modules XHTML est de définir un schéma qui soit un sous-ensemble d'un type de document de la famille XHTML (par exemple, parce qu'ils construisent des appareils ou des logiciels qui ne soutiennent qu'un sous-ensemble de XHTML). Cette définition crée simplement un pilote de schéma qui n'inclut pas les modules pertinents. Les créateurs de schémas devraient noter que l'élément redefine du schéma inclut par défaut tout le modèle de contenu du schéma référencé ; ils ne devraient pas non plus inclure les redéfinitions des modules qu'ils ne souhaitent pas inclure. Les étapes de base sont les suivantes :

  1. Prendre un schéma de la famille XHTML comme base du nouveau type de document (par exemple, XHTM 1.1) ;
  2. Sélectionner les modules à supprimer de ce schéma ;
  3. Supprimer physiquement du fichier pilote les éléments de schéma include et redefine qui incluent des modules non pertinents. Les références aux composantes de schéma de ces modules utilisées dans les redéfinitions d'autres modules doivent également être supprimées ;
  4. Introduire les nouveaux modules.

B.4.4. Création d'un nouveau type de document

Enfin, certains créateurs de schémas souhaiteront partir de zéro, en utilisant le cadre XHTML Modularization comme boîte à outils pour construire un nouveau langage de balisage. Ce langage doit contenir les modules fondamentaux obligatoires de XHTML. Il peut également contenir d'autres modules définis en XHTML ou tout autre module que l'auteur souhaite employer. Dans cet exemple, nous prendrons les modules XHTML obligatoires, ajouterons des modules définis en XHTML et ajouteront aussi le module que nous avons défini plus haut.

La première étape est de créer un module qui définit les éléments et attributs en utilisant le modèle fourni.

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/SCHEMA/examples/myml-module-1.xsd. La dernière version est disponible à 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="a_smodule_element_nomyotherelement" 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="a_smodule_element_nomyelement" type="myml.myelement.type"/>

  <!-- Note: Global attribute -->
  <xs:attribute name="myattr" type="xs:string"/>

</xs:schema>

Puis construire une description de modèle de contenu qui accroche les nouveaux éléments et attributs aux autres éléments XHTML. L'exemple suivant, qui est modélisé (patterned) d'après le modèle de contenu XHTML Basic, est un module de modèle de contenu complet et autonome (free-standing) :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/SCHEMA/examples/myml-model-1.xsd. La dernière version est disponible à 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="a_smodule_element_nohtml" type="xhtml.html.type"/>

</xs:schema>

Enfin, construire un schéma pilote. Pour faciliter l'extensibilité, ce schéma pilote est scindé en deux fichiers XML Schema. Le premier fichier du schéma pilote collecte (inclut) tous les modules nécessaires pour le nouveau type de document. Ce schéma pourvoit également les redéfinitions obligatoires des composantes de schéma dans les modules inclus. (Note — Dans XML Schema, l'élément redefine inclut le schéma référencé).

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/SCHEMA/examples/myml-modules-1.xsd. La dernière version est disponible à 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>

Le deuxième fichier du schéma pilote construit le nouveau type de document fondé sur le modèle de contenu et les modules. Ce schéma fournit également l'adresse (schemaLocation) de tous les espaces de noms importés (les espaces de noms importés par les modules inclus) :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/SCHEMA/examples/myml-1_0.xsd. La dernière version est disponible à 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 &#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>

Une fois le nouveau schéma développé, on peut l'utiliser dans tout document. Pour utiliser le schéma, il suffit de le référencer dans l'attribut schemaLocation de l'élément racine d'un document :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/SCHEMA/examples/myml-prefixed.html. La dernière version est disponible à 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>