Lisez-moi S.V.P. 

E. Développement de définitions DTD avec des modules définis et étendus

Sommaire

Cette section 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 qui sont fondés sur XHTML. Ces types de document peuvent étendre XHTML en intégrant des capacités supplémentaires (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 employer les concepteurs de types de document pour profiter de la mise en œuvre DTD XML de cette architecture de modularisation. Les techniques de 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 :

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

Dans certains cas, une extension de XHTML se réduit simplement à des attributs supplémentaires. On peut ajouter des attributs à un élément juste en spécifiant une liste ATTLIST supplémentaire pour l'élément. Par exemple :

<!ATTLIST %a.qname;
      %MyModule.pfx;myattr   CDATA        #IMPLIED
      %MyModule.xmlns.extras.attrib;
>

ajouterait l'attribut "myattr", avec un préfixe optionnel défini par "%MyModule.pfx", avec un type de valeur CDATA, à l'élément a; Cela fonctionne parce que XML permet la définition ou l'extension de la liste d'attributs d'un élément en tout point d'une définition DTD. 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.

Naturellement, ajouter un attribut à une définition DTD 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).

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

Définir des éléments supplémentaires n'est qu'un petit peu plus compliqué que définir des attributs supplémentaires. En gros, les créateurs de définitions DTD doivent écrire la déclaration d'élément de chaque élément :

<!-- In the qname sub-module -->
<!ENTITY % MyModule.myelement.qname  "%MyModule.pfx;myelement" >
<!ENTITY % MyModule.myotherelement.qname  "%MyModule.pfx;myotherelement" >

<!-- In the declaration sub-module -->
<!ELEMENT %MyModule.myelement.qname; 
           ( #PCDATA | %MyModule.myotherelement.qname; )* >
<!ATTLIST %MyModule.myelement.qname;
          myattribute    CDATA    #IMPLIED
>

<!ELEMENT %MyModule.myotherelement.qname; EMPTY >

Une fois les éléments définis, ils doivent être intégrés au modèle de contenu. Les stratégies d'intégration des nouveaux éléments ou jeux d'éléments sont traitées dans la section suivante.

E.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é, les créateurs de définitions DTD peuvent modifier le modèle de contenu de chaque élément dans chaque module. Les détails de l'interface des modules DTD sont décrits à la section Construction des modules DTD. Dans l'ensemble, il y a essentiellement deux façons d'aborder cette modification :

  1. Redéfinir l'entité paramètre ".content" de chaque élément ;
  2. Redéfinir une ou plusieurs des entités de modèle de contenu globales (normalement via des entités paramètres ".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.

E.3.1. Intégration d'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 seulement 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 établir une définition DTD qui soit 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 :

<!ENTITY % img.content "( %MyModule.myelement.qname; )*">

Une définition DTD avec ce modèle de contenu admettrait un document comme le fragment suivant :

<img src="...">
<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.

E.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 :

<!ENTITY % Misc.extra
     "| %MyModule.myelement.qname;" >

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.

E.4. Création d'une nouvelle définition DTD

Jusqu'ici les exemples dans cette section ont décrit les méthodes d'extension de XHTML et du modèle de contenu de XHTML. Cela étant fait, l'étape suivante est de collecter les modules qui composent la définition DTD en un seul pilote DTD (DTD driver), en incorporant les nouvelles définitions afin d'outrepasser et augmenter les définitions XHTML de base comme approprié.

E.4.1. Création d'une définition DTD simple

En utilisant l'exemple simple qui précède, il est possible de définir une nouvelle DTD qui utilise et étend assez facilement 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/DTD/examples/simpleml-model-1.mod. La dernière version est disponible à http://www.w3.org/MarkUp/DTD/examples/simpleml-model-1.mod.

<!-- File: simpleml-model-1.mod -->

<!-- Declare a Parameter Entity (PE) that defines any external namespaces 
     that are used by this module -->

<!-- Set the PE that is used in every ATTLIST in this module 
     NS.prefixed.attrib is initialized in the xhtml-qname module, and
     SimpleML.ns.noprefix.attrib is initialized in the SimpleML DTD driver 
     file.-->
<!ENTITY % SimpleML.xmlns.attrib
  "%NS.decl.attrib;"
>

<!ENTITY % SimpleML.Common.attrib
  "%SimpleML.xmlns.attrib;
   id           ID           #IMPLIED"
>

<!ENTITY % SimpleML.element.qname "%SimpleML.pfx;element" >
<!ENTITY % SimpleML.otherelement.qname "%SimpleML.pfx;otherelement" >

<!ELEMENT %SimpleML.element.qname;
          ( #PCDATA | %SimpleML.otherelement.qname; )* >
<!ATTLIST %SimpleML.element.qname;
          myattribute   CDATA  #IMPLIED
          %SimpleML.Common.attrib;
>
<!ELEMENT %SimpleML.otherelement.qname; EMPTY >
<!ATTLIST %SimpleML.otherelement.qname;
          %SimpleML.Common.attrib;
>

<!ENTITY % SimpleML.img.myattr.qname "%SimpleML.pfx;myattr" >
<!ATTLIST %img.qname;
          %SimpleML.img.myattr.qname;  CDATA  #IMPLIED
>

<!-- Add our elements to the XHTML content model -->
<!ENTITY % Misc.class
     "| %SimpleML.element.qname;" >

<!-- Now bring in the XHTML Basic content model -->
<!ENTITY % xhtml-basic-model.mod
     PUBLIC "-//W3C//ENTITIES XHTML Basic 1.0 Document Model 1.0//EN"
            "http://www.w3.org/TR/xhtml-basic/xhtml-basic10-model-1.mod" >
%xhtml-basic-model.mod;

Ensuite, définir le pilote DTD du nouveau langage :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/DTD/examples/simpleml-1_0.dtd. La dernière version est disponible à at http://www.w3.org/MarkUp/DTD/examples/simpleml-1_0.dtd.

<!-- file: simpleml-1_0.dtd -->

<!-- Bring in the XHTML datatypes -->
<!ENTITY % xhtml-datatypes.mod
     PUBLIC "-//W3C//ENTITIES XHTML Datatypes 1.0//EN"
            "http://www.w3.org/MarkUp/DTD/xhtml-datatypes-1.mod" >
%xhtml-datatypes.mod;

<!-- Declare the actual namespace of this module -->
<!ENTITY % SimpleML.xmlns "http://www.example.com/xmlns/simpleml1" >

<!-- By default, disable prefixing of new module -->
<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % SimpleML.prefixed "%NS.prefixed;" > 

<!-- Default prefix for module elements and attributes -->
<!ENTITY % SimpleML.prefix "simpleml" >

<!-- If this module's namespace is prefixed -->
<![%SimpleML.prefixed;[
  <!ENTITY % SimpleML.pfx  "%SimpleML.prefix;:" >
]]>
<!ENTITY % SimpleML.pfx  "" >

<![%SimpleML.prefixed;[
  <!ENTITY % SimpleML.xmlns.extra.attrib 
       "xmlns:%SimpleML.prefix; %URI.datatype; #FIXED '%SimpleML.xmlns;'" >
]]>
<!ENTITY % SimpleML.xmlns.extra.attrib "" >

<!ENTITY % XHTML.xmlns.extra.attrib
       "%SimpleML.xmlns.extra.attrib;"
>
<!-- Set the content model for our language -->
<!ENTITY % xhtml-model.mod
     SYSTEM "simpleml-model-1.mod" >
<!-- Instantiate xhtml basic's DTD to do all the work -->
<!ENTITY % xhtml-basic.dtd
     PUBLIC "-//W3C//DTD XHTML Basic 1.0//EN" 
            "http://www.w3.org/TR/xhtml-basic/xhtml-basic10.dtd" >
%xhtml-basic.dtd;

Lors de l'utilisation de cette définition DTD, il est possible d'activer l'utilisation de préfixes d'espace de noms XML. Ce faisant, le début d'un document utilisant cette nouvelle définition DTD pourrait ressembler à ceci :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/DTD/examples/simple-prefixed.html. La dernière version est disponible à http://www.w3.org/MarkUp/DTD/examples/simple-prefixed.html.

<!DOCTYPE html SYSTEM "simpleml-1_0.dtd" [
  <!ENTITY % SimpleML.prefixed "INCLUDE">
]>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:simpleml="http://www.example.com/xmlns/simpleml1" >
<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>

E.4.2. Création d'une définition DTD 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 simple ci-dessus, les seules différences étant que le module ajouté est incorporé à la définition DTD par référence plutôt que d'inclure explicitement les nouvelles définitions dans la définition DTD.

Un tel module complexe est la définition DTD de [MATHML]. Pour combiner MathML et XHTML en une seule définition DTD, l'auteur devrait juste décider où le contenu MathML serait légal dans le document et ajouter l'élément racine de MathML au modèle de contenu à cet endroit. D'abord, définir un module de modèle de contenu qui instancie la définition DTD de MathML et l'attacher au modèle de contenu :

<!-- File: mathml-model.mod -->
<!ENTITY % XHTML1-math
     PUBLIC "-//W3C//DTD MathML 2.0//EN"
            "http://www.w3.org/TR/MathML2/dtd/mathml2.dtd" >
%XHTML1-math;

<!ENTITY % Inlspecial.extra 
     "%a.qname; | %img.qname; | %object.qname; | %map.qname; 
      | %Mathml.Math.qname;" >

Ensuite, définir un pilote DTD qui identifie notre nouveau module de modèle de contenu comme étant le modèle de contenu de la définition DTD et qui passe, par exemple, le traitement au pilote XHTML 1.1 :

<!-- File: xhtml-mathml.dtd -->
<!ENTITY % xhtml-model.mod
      SYSTEM "mathml-model.mod" >
<!ENTITY % xhtml11.dtd
     PUBLIC "-//W3C//DTD XHTML 1.1//EN"
            "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd" >
%xhtml11.dtd;

E.4.3. Création d'une définition DTD par suppression et remplacement de modules XHTML

Une autre méthode avec laquelle les créateurs de définitions DTD peuvent utiliser les modules XHTML est d'établir une définition DTD qui est 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 méthode est légèrement plus complexe que celle de l'exemple précédent. Les étapes de base sont les suivantes :

  1. Prendre une définition DTD de la famille XHTML comme base du nouveau type de document (nous utiliserons XHTML 1.1) ;
  2. Sélectionner les modules à supprimer de cette définition DTD ;
  3. Établir une nouvelle définition DTD qui « IGNORE » les modules ;
  4. Introduire les nouveaux modules.

Par exemple, prenons le cas d'un appareil qui utilise les modules XHTML hormis ceux relatifs aux formulaires et aux tables. La définition DTD d'un tel appareil ressemblerait à ceci :

<!-- File: xhtml-simple.dtd -->
<!ENTITY % xhtml-form.module "IGNORE" >
<!ENTITY % xhtml-table.module "IGNORE" >
<!ENTITY % xhtml-table.module "IGNORE" >
<!-- Bring in the basic tables module -->
<!ENTITY % xhtml-basic-table.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Basic Tables 1.0//EN"
       "http://www.w3.org/MarkUp/DTD/xhtml-basic-table-1.mod"
>
%xhtml-basic-table.mod;
<!ENTITY % xhtml11.mod
     PUBLIC "-//W3C//DTD XHTML 1.1//EN"
            "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd" >
%xhtml11.mod;

Notez que l'on ne modifie pas réellement le modèle de contenu de la définition DTD de XHTML 1.1. Toujours est-il que, puisque XML ignore les éléments des modèles de contenu qui ne sont pas définis, les éléments de formulaire et de table sont automatiquement exclus du modèle.

E.4.4. Création d'une nouvelle définition DTD

Enfin, certains créateurs de définitions DTD 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, ajouterons quelques modules définis en XHTML et ajouterons aussi le module que nous avons défini plus haut.

La première étape est d'utiliser le modèle fourni par XHTML pour un nouveau module des noms qualifiés, modifié pour définir les noms qualifiés et l'espace de noms de nos nouveaux éléments.

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/DTD/examples/myml-qname-1.mod. La dernière version est disponible à at http://www.w3.org/MarkUp/DTD/examples/myml-qname-1.mod.

<!-- file: myml-qname-1.mod -->

<!-- Bring in the datatypes - we use the URI.datatype PE for declaring the
     xmlns attributes. -->
<!ENTITY % MyML-datatypes.mod
         PUBLIC "-//W3C//ENTITIES XHTML Datatypes 1.0//EN"
         "http://www.w3.org/MarkUp/DTD/xhtml-datatypes-1.mod" >
%MyML-datatypes.mod;

<!-- By default, disable prefixing of this module -->
<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % MyML.prefixed "%NS.prefixed;" >

<!-- Declare the actual namespace of this module -->
<!ENTITY % MyML.xmlns "http://www.example.com/xmlns/myml" >

<!-- Declare the default prefix for this module -->
<!ENTITY % MyML.prefix "myml" >

<!-- If this module's namespace is prefixed -->
<![%MyML.prefixed;[
  <!ENTITY % MyML.pfx  "%MyML.prefix;:" >
]]>
<!ENTITY % MyML.pfx  "" >

<!-- This entity is ALWAYS prefixed, for use when adding our
     attributes to an element in another namespace -->
<!ENTITY % MyML.xmlns.attrib.prefixed
   "xmlns:%MyML.prefix;  %URI.datatype;  #FIXED '%MyML.xmlns;'"
>

<!-- Declare a Parameter Entity (PE) that defines any external namespaces 
     that are used by this module -->
<!ENTITY % MyML.xmlns.extra.attrib "" >

<!-- If we want to use xhtml namespace attributes on our elements, then
     we need a prefix for them; default to xhtml. -->
<!ENTITY % XHTML.prefix "xhtml" >

<!-- Declare a PE that defines the xmlns attributes for use by MyML. -->
<![%MyML.prefixed;[
<!ENTITY % MyML.xmlns.attrib
   "%MyML.xmlns.attrib.prefixed;
    %MyML.xmlns.extra.attrib;"
>
<!-- Make sure that the MyML namespace attributes are included on the XHTML
     attribute set -->
<!ENTITY % XHTML.xmlns.extra.attrib
    "xmlns:%XHTML.prefix;  %URI.datatype;  #FIXED 'http://www.w3.org/1999/xhtml'
    %MyML.xmlns.attrib;" >
]]>
<!-- if we are not prefixed, then our elements should have the default
     namespace AND the prefixed namespace is added to the XHTML set
     because our attributes can be referenced on those elements
-->
<!ENTITY % MyML.xmlns.attrib
   "xmlns   %URI.datatype;  #FIXED '%MyML.xmlns;'
    %MyML.xmlns.extra.attrib;"
>
<!ENTITY % XHTML.xmlns.extra.attrib
   "xmlns:%XHTML.prefix;  %URI.datatype;  #FIXED 'http://www.w3.org/1999/xhtml'
    %MyML.xmlns.attrib.prefixed;"
>
<!-- Now declare the element names -->

<!ENTITY % MyML.myelement.qname "%MyML.pfx;myelement" >
<!ENTITY % MyML.myotherelement.qname "%MyML.pfx;myotherelement" >

Ensuite, établir un module qui définit les éléments et attributs en utilisant le modèle fourni par XHTML.

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/DTD/examples/myml-elements-1.mod. La dernière version est disponible à http://www.w3.org/MarkUp/DTD/examples/myml-elements-1.mod.

<!-- ...................................................................... -->
<!-- My Elements Module ................................................... -->
<!-- file: myml-elements-1_0.mod

     PUBLIC "-//MY COMPANY//ELEMENTS XHTML MyML Elements 1.0//EN"
     SYSTEM "http://example.com/DTDs/myml-elements-1_0.mod"

     xmlns:myml="http://example.com/DTDs/myml-1_0.dtd"
     ...................................................................... -->

<!-- My Elements Module

     myelement
     myotherelement

     This module has no purpose other than to provide structure for some
     PCDATA content.
-->

<!ELEMENT %MyML.myelement.qname;
     ( #PCDATA | %MyML.myotherelement.qname; )* >
<!ATTLIST %MyML.myelement.qname;
     myattribute    CDATA   #IMPLIED
     %MyML.xmlns.attrib;
     %XHTML.global.common.attrib;
>

<!ELEMENT %MyML.myotherelement.qname; EMPTY >
<!ATTLIST %MyML.myotherelement.qname;
     %MyML.xmlns.attrib;
     %XHTML.global.common.attrib;
>

<!ENTITY % MyML.img.myattr.qname "%MyML.prefix;:myattr" >
<!ATTLIST %img.qname;
      %MyML.img.myattr.qname;   CDATA  #IMPLIED
      %MyML.xmlns.attrib.prefixed;
>

<!-- end of myml-elements-1_0.mod -->

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é à partir du modèle de contenu de XHTML Basic, est un module de modèle de contenu complet et autonome :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/DTD/examples/myml-model-1.mod. La dernière version est disponible à at http://www.w3.org/MarkUp/DTD/examples/myml-model-1.mod.

<!-- ...................................................................... -->
<!-- MyML Model Module  ................................................... -->
<!-- file: myml-model-1.mod

     PUBLIC "-//MY COMPANY//ELEMENTS XHTML MyML Model 1.0//EN"
     SYSTEM "http://example.com/DTDs/myml-model-1_0.mod"

     xmlns:myml="http://www.example.com/xmlns/myml"
     ...................................................................... -->

<!-- Define the content model for Misc.extra -->
<!ENTITY % Misc.class
     "| %MyML.myelement.qname; ">

<!-- ....................  Inline Elements  ...................... -->

<!ENTITY % HeadOpts.mix  
     "( %meta.qname; )*" >

<!ENTITY % I18n.class "" >

<!ENTITY % InlStruct.class "%br.qname; | %span.qname;" >

<!ENTITY % InlPhras.class
     "| %em.qname; | %strong.qname; | %dfn.qname; | %code.qname; 
      | %samp.qname; | %kbd.qname; | %var.qname; | %cite.qname; 
      | %abbr.qname; | %acronym.qname; | %q.qname;" >

<!ENTITY % InlPres.class
     "" >

<!ENTITY % Anchor.class "| %a.qname;" >

<!ENTITY % InlSpecial.class "| %img.qname; " >

<!ENTITY % Inline.extra "" >

<!-- %Inline.class; includes all inline elements,
     used as a component in mixes
-->
<!ENTITY % Inline.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %Anchor.class;
      %InlSpecial.class;"
>

<!-- %InlNoAnchor.class; includes all non-anchor inlines,
     used as a component in mixes
-->
<!ENTITY % InlNoAnchor.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %InlSpecial.class;"
>

<!-- %InlNoAnchor.mix; includes all non-anchor inlines
-->
<!ENTITY % InlNoAnchor.mix
     "%InlNoAnchor.class;
      %Misc.class;"
>

<!-- %Inline.mix; includes all inline elements, including %Misc.class;
-->
<!ENTITY % Inline.mix
     "%Inline.class;
      %Misc.class;"
>

<!-- .....................  Block Elements  ...................... -->

<!ENTITY % Heading.class 
     "%h1.qname; | %h2.qname; | %h3.qname; 
      | %h4.qname; | %h5.qname; | %h6.qname;" >

<!ENTITY % List.class "%ul.qname; | %ol.qname; | %dl.qname;" >

<!ENTITY % BlkStruct.class "%p.qname; | %div.qname;" >

<!ENTITY % BlkPhras.class 
     "| %pre.qname; | %blockquote.qname; | %address.qname;" >

<!ENTITY % BlkPres.class "" >

<!ENTITY % Block.extra "" >

<!-- %Block.class; includes all block elements,
     used as an component in mixes
-->
<!ENTITY % Block.class
     "%BlkStruct.class;
      %BlkPhras.class;
      %BlkPres.class;
      %Block.extra;"
>

<!-- %Block.mix; includes all block elements plus %Misc.class;
-->
<!ENTITY % Block.mix
     "%Heading.class;
      | %List.class;
      | %Block.class;
      %Misc.class;"
>

<!-- ................  All Content Elements  .................. -->

<!-- %Flow.mix; includes all text content, block and inline
-->
<!ENTITY % Flow.mix
     "%Heading.class;
      | %List.class;
      | %Block.class;
      | %Inline.class;
      %Misc.class;"
>

<!-- special content model for pre element -->
<!ENTITY % pre.content
    "( #PCDATA
     | %Inline.class; )*"
>

<!-- end of myml-model-1.mod -->

Enfin, utiliser le modèle fourni par XHTML pour une nouvelle définition DTD, modifié comme il se doit pour notre nouveau langage de balisage :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/DTD/examples/myml-1_0.dtd. La dernière version est disponible à at http://www.w3.org/MarkUp/DTD/examples/myml-1_0.dtd.

<!-- ....................................................................... -->
<!-- MYML DTD  ............................................................. -->
<!-- file: myml-1_0.dtd -->

<!-- This is the DTD driver for myml 1.0.

     Please use this formal public identifier to identify it:

         "-//MY COMPANY//DTD XHTML MYML 1.0//EN"

     And this namespace for myml-unique elements:

         xmlns:myml="http://www.example.com/xmlns/myml"
-->
<!ENTITY % XHTML.version  "-//MY COMPANY//DTD XHTML MYML 1.0//EN" >

<!-- reserved for use with document profiles -->
<!ENTITY % XHTML.profile  "" >

<!-- Tell the framework to use our qualified names module as an extra qname
driver -->
<!ENTITY % xhtml-qname-extra.mod
     SYSTEM "myml-qname-1.mod" >

<!-- Define the Content Model for the framework to use -->
<!ENTITY % xhtml-model.mod
     SYSTEM "myml-model-1.mod" >

<!-- Disable bidirectional text support -->
<!ENTITY % XHTML.bidi  "IGNORE" >

<!-- Bring in the XHTML Framework -->
<!ENTITY % xhtml-framework.mod
     PUBLIC "-//W3C//ENTITIES XHTML Modular Framework 1.0//EN"
            "http://www.w3.org/MarkUp/DTD/xhtml-framework-1.mod" >
%xhtml-framework.mod;

<!-- Basic Text Module (Required)  ............................... -->
<!ENTITY % xhtml-text.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Basic Text 1.0//EN"
            "http://www.w3.org/MarkUp/DTD/xhtml-text-1.mod" >
%xhtml-text.mod;

<!-- Hypertext Module (required) ................................. -->
<!ENTITY % xhtml-hypertext.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Hypertext 1.0//EN"
            "http://www.w3.org/MarkUp/DTD/xhtml-hypertext-1.mod" >
%xhtml-hypertext.mod;

<!-- Lists Module (required)  .................................... -->
<!ENTITY % xhtml-list.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Lists 1.0//EN"
            "http://www.w3.org/MarkUp/DTD/xhtml-list-1.mod" >
%xhtml-list.mod;

<!-- My Elements Module   ........................................ -->
<!ENTITY % MyML-elements.mod
     SYSTEM "myml-elements-1.mod" >
%MyML-elements.mod;

<!-- XHTML Images module  ........................................ -->
<!ENTITY % xhtml-image.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Images 1.0//EN"
            "http://www.w3.org/MarkUp/DTD/xhtml-image-1.mod" >
%xhtml-image.mod;

<!-- Document Metainformation Module  ............................ -->
<!ENTITY % xhtml-meta.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Metainformation 1.0//EN"
            "http://www.w3.org/MarkUp/DTD/xhtml-meta-1.mod" >
%xhtml-meta.mod;

<!-- Document Structure Module (required)  ....................... -->
<!ENTITY % xhtml-struct.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Document Structure 1.0//EN"
            "http://www.w3.org/MarkUp/DTD/xhtml-struct-1.mod" >
%xhtml-struct.mod;

E.5. Utilisation de la nouvelle définition DTD

Une fois la nouvelle définition DTD développée, on peut l'utiliser dans tout document. Pour utiliser la définition DTD, il suffit juste de la référencer dans la déclaration DOCTYPE du document :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/DTD/examples/myml-noprefix.xhtml. La dernière version est disponible à http://www.w3.org/MarkUp/DTD/examples/myml-noprefix.xhtml.

<!DOCTYPE html SYSTEM "myml-1_0.dtd" >
<html xmlns="http://www.w3.org/1999/xhtml" 
      xmlns:xhtml="http://www.w3.org/1999/xhtml" 
      xmlns:myml="http://www.example.com/xmlns/myml" >
<head>
<title>An example using defaults</title>
</head>
<body>
<p>This is content in the XHTML namespace</p>
<myelement xhtml:id="myid" xhtml:class="localElement">
  This is content in the SimpleML namespace.
  <myotherelement />
</myelement>
<p><img src="missing" alt="Missing image" myml:myattr="value"/></p>
</body>
</html>

Le document peut également utiliser les éléments hors de l'espace de noms XHTML en les préfixant :

Cette version du fichier est récupérable à http://www.w3.org/TR/2008/REC-xhtml-modularization/DTD/examples/myml-prefixed.xhtml. La dernière version est disponible à http://www.w3.org/MarkUp/DTD/examples/myml-prefixed.xhtml.

<!DOCTYPE html SYSTEM "myml-1_0.dtd" [
  <!ENTITY % MyML.prefixed "INCLUDE" >
]>
<html xmlns="http://www.w3.org/1999/xhtml" 
      xmlns:xhtml="http://www.w3.org/1999/xhtml" 
      xmlns:myml="http://www.example.com/xmlns/myml" >
<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>