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 :
Une organisation fournit de l'information à ses abonnés via une interface web. L'organisation stocke les renseignements sur ses abonnés dans une base de données fondée sur XML. Une manière de faire état de ces renseignements de la base de données au Web est d'incorporer les enregistrements XML de la base de données directement dans le document XHTML. Bien qu'il soit possible de simplement incorporer les enregistrements, l'organisation pourrait définir un module qui décrit les enregistrements, attacher ce module à une mise en œuvre XHTML et ainsi créer un langage de balisage complet pour les pages. L'organisation peut alors accéder aux données dans les nouveaux éléments via le modèle objet de document (Document Object Model) [DOM], valider les documents, fournir des définitions de style pour les éléments en cascade à l'aide de feuilles de style en cascade (Cascading Style Sheets) [CSS2], etc. À prendre le temps de définir la structure de leurs données et de créer une définition DTD en observant les processus définis dans cette section, l'organisation peut profiter entièrement des avantages de XML.
Un développeur de client Internet conçoit un appareil spécialisé. Cet appareil ne soutiendra qu'un sous-ensemble de XHTML, et l'appareil accèdera toujours à l'Internet via un serveur mandataire qui valide le contenu avant de le passer au client (afin de réduire la gestion des erreurs par le client). Pour s'assurer que le contenu est valide, le développeur crée un langage de balisage qui est un sous-ensemble de XHTML en employant les processus définis dans cette section. Il utilise ensuite la nouvelle définition de langage dans son serveur mandataire et son appareil, et met également la définition de langage à la disposition des développeurs de contenu afin que ceux-ci puissent valider leurs contenus avant de les publier. En observant quelques étapes simples, le développeur du client peut utiliser l'architecture définie dans ce document pour réduire considérablement le coût de développement de son langage et s'assurer de soutenir entièrement le sous-ensemble de XHTML qu'il a choisi d'inclure.
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).
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.
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 :
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.
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 :
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.
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.
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é.
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>
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;
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 :
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.
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;
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>