E. DTD's ontwerpen met gedefinieerde en uitbreidingsmodules

Inhoud

E.1. Definiëren van aanvullende attributen
E.2. Definiëren van aanvullende elementen
E.3. Definiëren van het inhoudsmodel voor een verzameling van modules
- E.3.1. Een stand-alone module integreren in XHTML
- E.3.2. Een nieuwe module mixen door de modules in XHTML
E.4. Een nieuwe DTD maken
- E.4.1. Een eenvoudige DTD maken
- E.4.2. Een DTD maken door XHTML uit te breiden
- E.4.3. Een DTD maken door XHTML modules te verwijderen en te vervangen
- E.4.4. Een nieuwe DTD maken
E.5. Een nieuwe DTD gebruiken

Deze appendix is informatief.

Het primary doel van definiëren van XHTML modules en een algemene modularisatie methodologie is het ontwikkelgemak van documenttypes die gebaseerd zijn op XHTML. Deze document types kunnen XHTML uitbreiden door integratie van aanvullende mogelijkheden (zoals [SMIL]), of ze kunnen een subset van XHTML definiëren voor het gebruik in een gespecialiseerd toestel. Dit deel omschrijft de technieken die document typeontwerpers moeten gebruiken om de XML DTD implementatie van deze modularisatie architectuur uit te buiten. Het doet dit door gaandeweg complexere toepassing van de XHTML Modularisatie technieken in de aanmaak van een compleet document type door culmineren van verschillende modules.

Merk op dat deze voorbeelden in geen geval de aanpassing van de de door XHTML voorziene module bestand entiteiten zelf vereisen. De XHTML module bestand entiteiten worden volledig geparameteriseerd, zodat het mogelijk is om via verschillende module definities en driver bestanden de definitie en het inhoudsmodel van elk element en elke elementhierarchie aan te passen.

Onhoudt tot slot dat er van de meeste gebruikers van XHTML niet verwacht wordt dat ze DTD auteurs zijn. DTD auteurs zijn in het algemeen mensen die gespecialiseerde opmaak definiëren die de leesbaarheid, de eenvoud van weergave van een document of gemak van machineverwerking van documenten verhogen. DTD auteurs kunnen ook client ontwerpers zijn die de gespecialiseerde DTD definiëren voor hun specifieke client. Beschouw de volgende gevallen:

Een organisatie biedt informatie van de abonnee's via een Web interface. De organisatie bewaart de informatie van de abonnee in een XML-gebaseerde database. Een manier om deze informatie vanuit de database naar het Web te rapporteren is door de XML records van de database direct op te nemen in het XHTML document. Hoewel het mogelijk is om enkel de records op te nemen, zou de organisatie een DTD module kunnen definiëren die de records omschrijft, deze module koppelen aan een XHTML DTD en daarbij een complete DTD voor de pagina's maken. De organisatie kan dan toegang krijgen tot de data met nieuwe elementen via het Document Object Model [DOM], de documenten valideren, stijldefinities voorzien voor de elementen die cascaden door gebruik van Cascading Style Sheets [CSS2], enz. Door de tijd te nemen om de structuur van hun data te definiëren en een DTD te maken door gebruikt van de processen gedefinieerd in dit deel, kan de organisatie de volledige voordelen van XML benutten.
Een Internet client ontwikkelaar ontwerpt een gespecialiseerd toestel. Dat toestel zal enkel een subset van XHTML ondersteunen en het toestel zal altijd toegang krijgen tot het Internet via een proxy server die de inhoud valideert voordat het naar de client gestuurd wordt (om error handling op de client te minimaliseren). Om te garanderen dat de inhoud geldig is maakt de ontwikkelaar een DTD die een subset van XHTML is door gebruik te maken van de processen gedefinieerd in dit deel. Hij kan dan de nieuwe DTD gebruiken in zijn proxy server en in zijn toestellen en zo de DTD ook beschikbaar maken voor inhoudontwikkelaars zodat ontwikkelaars hun inhoud kunnen valideren voordat ze deze beschikbaar maken. Door het uitvoeren van een paar eenvoudige stappen kan de client ontwikkelaar de architectuur gedefinieerd in dit document gebruiken om de ontwikkeling van zijn DTD te vergemakkelijken en te verzekeren dat ze volledig de subset van XHTML, die ze wensen op te nemen, te ondersteunen.

E.1. Definiëren van aanvullende attributen

In een aantal kan een uitbreiding van XHTML zo eenvoudig zijn als aanvullende attributen. Attributen kunnen aan een element toegevoegd worden door enkel een aanvullende ATTLIST voor het element te specificeren, bijvoorbeeld:

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

zou het "mijnattr" attribuut toevoegen met een optionele prefix gedefinieerd door "%MijnModule.pfx", met een waardetype CDATA voor het "a" element. Dit werkt omdat XML de definitie of uitsluiting van de attribuutlijst voor een element toelaat op elk punt in een DTD. Raadpleeg voor een bespreking van gekwalificeerde namen en namespace prefixen Definitie van de Namespace van een Module.

Toevoegen van een attribuut aan een DTD betekent uiteraard niet dat een nieuw gedrag gedefinieerd wordt voor clients. Een inhoudontwikkelaar kan (bijvoorbeeld) een extra attribuut gebruiken om informatie in te bewaren die gebruikt wordt door gekoppelde scripts via het Document Object Model.

E.2. Definiëren van aanvullende elementen

Definiëren van aanvullende elementen is weinig moeilijker dan definiëren van aanvullende attributen. DTD auteurs zouden de element declaratie voor elk element moeten schrijven:

<!-- In de qname sub-module -->
<!ENTITY % MijnModule.mijnelement.qname  "%MijnModule.pfx;mijnelement" >
<!ENTITY % MijnModule.mijnanderelement.qname  "%MijnModule.pfx;mijnanderelement" >

<!-- In de declaratie sub-module -->
<!ELEMENT %MijnModule.mijnelement.qname; 
           ( #PCDATA | %MijnModule.mijnanderelement.qname; )* >
<!ATTLIST %MijnModule.mijnelement.qname;
          mijnattribute    CDATA    #IMPLIED
>

<!ELEMENT %MijnModule.mijnanderelement.qname; EMPTY >

Nadat de elementen gedefinieerd zijn, moeten ze geïntegreerd worden in het inhoudsmodel. Strategiëen voor integratie van nieuwe elementen of sets van elementen in het inhoudsmodel worden bekeken in het volgende deel.

E.3. Definiëren van het inhoudsmodel voor een verzameling van modules

Aangezien het inhoudsmodel van XHTML modules volledig geparameteriseerd is, mogen DTD auteurs het inhoudsmodel aanpassen voor elk element in elke module. De details van de DTD module interface worden gedefinieerd in DTD Modules bouwen. Er zijn fundamenteel twee manieren om deze aanpassing te benaderen:

Herdefinieer de ".content" parameter entiteit voor elk element.
Herdefinieer één of meer van de globale inhoudsmodelentiteiten (normaal via de ".extras" parameter entiteit).

De gekozen strategie zal afhangen van de aard van de gecombineerde modules en de aard van de geïntegreerde elementen. De rest van dit deel omschrijft technieken voor integratie van twee verschillende classen van modules.

E.3.1. Een stand-alone module integreren in XHTML

Als een module (onthoudt dat een module een collectie van andere modules kan zijn) elementen bevat die enkel verwijzen naar elkaar in hun inhoudsmodel, wordt gezegdt dat het "intern volledig (internally complete)" is. Zo kan de module op zichzelf gebruikt worden; (je kan bijvoorbeeld een DTD definiëren die bestaat uit één module en één van zijn elementen gebruikt als root element). Integreren van zo een module in XHTML is een proces uit drie stappen:

Beslis welk(e) element(en) gezien kunnen worden als de root(s) van de nieuwe module.
Beslis waar deze elementen gekoppeld worden in de XHTML inhoudsboom.
Voeg dan voor elk koppelpunt in de inhoudsboom de root element(en) toe aan de inhoudsdefinitie voor de XHTML elementen.

Beschouw het koppelen van de elementen hierboven gedefinieerd. In dat voorbeeld is het element mijnelement de root. Om dit element te koppelen onder het img element en enkel het img element van XHTML, zou het volgende werken:

<!ENTITY % img.content "( %MijnModule.mijnelement.qname; )*">

Een DTD gedefinieerd met dit inhoudsmodel zou een document zoals het volgende fragment toelaten:

<img src="...">
<mijnml:mijnelement >Dit is inhoud van een lokaal gedefinieerd element</mijnml:mijnelement>
</img>

Het is belangrijk om op te merken dat het img element normaal als inhoudsmodel EMPTY heeft. Door het toevoegen van mijnelement aan dat inhoudsmodel wordt EMPTY vervangen door mijnelement. In het geval van andere elementen die al inhoudsmodellen gedefinieerd hebben, zal de toevoeging van een het herstarten van het bestaande inhoudsmodel vereisen in aanvulling van mijnelement.

E.3.2. Een nieuwe module mixen door de modules in XHTML

Uitbreidend op het bovenstaande voorbeeld, zou om deze module overal te koppelen zoals volgens het %Flow.mix inhoudsmodel groep toegelaten wordt, iets zoals het volgende vereisen:

<!ENTITY % Misc.extra
     "| %MijnModule.mijnelement.qname;" >

Omdat de %Misc.extra inhoudsmodel classe gebruikt wordt in de %Misc.class parameter entiteit en deze parameter entiteit gebruikt wordt doorheen de XHTML modules, zou de nieuwe module beschikbaar worden doorheen een uitgebreid XHTML document type.

E.4. Een nieuwe DTD maken

Tot hier hebben de voorbeelden in dit deel de methoden van uitbreiding van XHTML en het inhoudsmodel van XHTML omschreven. Als dit gedaan is, wordt de volgende stap het verzamelen van de modules die de DTD samenbrengen in een DTD driver waarbij de nieuwe definities opgenomen worden zodat ze de basis XHTML definities op een gepaste manier overriden en aanvullen.

E.4.1. Een eenvoudige DTD maken

Door gebruik te maken van het triviale voorbeeld hierboven is het eenvoudig mogelijk om een nieuwe DTD te definiëren die de XHTML modules gebruikt en uitbreid. Definieer eerst de nieuwe elementen en hun inhoudsmodel in een module:

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

<!-- Declareer een Parameter Entiteit (PE) die alle externe namespaces 
     definieert die gebruikt worden in deze module -->

<!-- Set de PE die gebruikt wordt in elke ATTLIST in deze module 
     NS.prefixed.attrib wordt geïnitialiseerd in de xhtml-qname module en
     SimpleML.ns.noprefix.attrib wordt geïnitialiseerd in het SimpleML DTD 
	 driver bestand.-->
<!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.anderelement.qname "%SimpleML.pfx;anderelement" >

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

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

<!-- Voeg onze elementen toe aan het XHTML inhoudsmodel -->
<!ENTITY % Misc.class
     "| %SimpleML.element.qname;" >

<!-- Voeg nu het XHTML Basis inhoudsmodel toe -->
<!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;

Definieer vervolgens de DTD driver voor de nieuwe taal:

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

<!-- Voeg de XHTML datatypes toe -->
<!ENTITY % xhtml-datatypes.mod
     PUBLIC "-//W3C//ENTITIES XHTML Datatypes 1.0//EN"
            "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-datatypes-1.mod" >
%xhtml-datatypes.mod;

<!-- Declareer de eigenlijke namespace van deze module -->
<!ENTITY % SimpleML.xmlns "http://www.voorbeeld.com/xmlns/simpleml1" >

<!-- Deactiveer standaard prefixing van de nieuwe module -->
<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % SimpleML.prefixed "%NS.prefixed;" > 

<!-- Standaard prefix voor module elementen en attributen -->
<!ENTITY % SimpleML.prefix "simpleml" >

<!-- Als de namespace van deze module geprefixed is -->
<![%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 het inhoudsmodel voor onze taal -->
<!ENTITY % xhtml-model.mod
     SYSTEM "simpleml-model-1.mod" >
<!-- Laat de DTD van xhtml basic al het werk doen -->
<!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;

Wanneer deze DTD gebruikt wordt is het mogelijk om het gebruik van XML namespace prefixes te activeren. Als dit gedaan wordt zou de start van een document die deze nieuwe DTD gebruikt kunnen uitzien als:

<!DOCTYPE html SYSTEM "simpleml-1_0.dtd" [
  <!ENTITY % SimpleML.prefixed "INCLUDE">
]>
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:simpleml="http://www.voorbeeld.com/xmlns/simpleml1" >
<head>
<title>Een standaard voorbeeld</title>
</head>
<body>
<p>Dit is inhoud in de XHTML namespace</p>
<simpleml:element>
  Dit is inhoud in de SimpleML namespace.
  <simpleml:anderelement />
</simpleml:element>
<p><img src="missing" alt="Missing image" simpleml:mijnattr="value"/></p>
</body>
</html>

E.4.2. Een DTD maken door XHTML uit te breiden

Vervolgens bestaat de situatie waar een complete, aanvullende en complexe module toegevoegd wordt aan XHTML (of een subset van XHTML wordt). In wezen is dit hetzelfde als in het triviale voobeeld hierboven, het enige verschik is dat de module die toegevoegd wordt opgebomen wordt in de DTD door verwijzing (by reference) in plaats van door expliciete opname van de nieuwe definities in de DTD.

Een dergelijke complexe module is de DTD voor [MATHML]. Om MathML en XHTML te combineren in één enkele DTD moet een auteur enkel bepalen waar MathML inhoud geldig is in het document en het MathML root element toevoegen aan het inhoudsmodel op dat punt. Definieer eerst een inhoudsmodel module die de MathML DTD vastlegt en koppelt aan het inhoudsmodel:

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

Definieer vervolgens een DTD driver die onze nieuwe inhoudsmodel module identificeert als het inhoudsmodel voor de DTD en (bijvoorbeeld) de processingafhandeling doorgeeft aan de XHTML 1.1 driver:

<!-- 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. Een DTD maken door XHTML modules te verwijderen en te vervangen

Een andere manier waarin DTD auteurs XHTML modules mogen gebruiken is bij de definitie van een DTD die een subset is van een XHTML family document type (omdat men bijvoorbeeld toestellen of software bouwt die enkel een subset van XHTML ondersteunt). Dit doen is weinig complexer dan het voorgaande voorbeeld. De basisstappen die gevolgd moeten worden zijn:

Neem een XHTML family DTD als de basis voor het nieuwe document type (we zullen XHTML 1.1 gebruiken).
Selecteer de modules die verwijderd moeten worden van deze DTD.
Definieer een nieuwe DTD die de modules negeert ("IGNORE").
Introduceer enkele nieuwe modules.

Beschouw bijvoorbeeld een toestel dat XHTML modules gebruikt maar zonder formulieren of tabellen. De DTD voor zo een toestel zou uitzien zoals dit:

<!-- File: xhtml-simple.dtd -->
<!ENTITY % xhtml-form.module "IGNORE" >
<!ENTITY % xhtml-table.module "IGNORE" >
<!ENTITY % xhtml-table.module "IGNORE" >
<!-- Voeg de basis tabellen module in -->
<!ENTITY % xhtml-basic-table.mod
     PUBLIC "-//W3C//ELEMENTS XHTML Basic Tables 1.0//EN"
       "http://www.w3.org/TR/xhtml-modularization/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;

Merk op dat dit niet werkelijk het inhoudsmodel van de XHTML 1.1 DTD aanpast. Aangezien XML elementen in inhoudsmodellen die niet gedefinieerd zijn negeert, worden de form en table elementen automatisch uit het model gegooid.

E.4.4. Een nieuwe DTD maken

Tot slot wensen sommige DTD auteurs te beginnen uit niets, gebruik makend van het XHTML Modularisatie framework als een gereedschapskoffer om een nieuwe opmaaktaal te maken. Deze taal moet gemaakt zijn uit de minimaal vereiste modules van XHTML. Het kan ok andere XHTML-gedefinieerde modules of elke andere module bevatten die de auteur wenst te gebruiken. In dit voorbeeld nemen we de XHTML vereiste modules en enkele XHTML-gedefinieerde modules en voegen daarbij de bovenstaande module.

De eerste stap is om de XHTML-voorziene template te gebruiken voor een nieuwe gekwalificeerde names module, aangepast om de gekwalificeerde names en namespace voor onze nieuwe elementen te definiëren.

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

<!-- Voeg de datatypes in - we gebruiken de URI.datatype PE voor declaratie van de 
     xmlns attributen. -->
<!ENTITY % MijnML-datatypes.mod
         PUBLIC "-//W3C//ENTITIES XHTML Datatypes 1.0//EN"
         "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-datatypes-1.mod" >
%MijnML-datatypes.mod;

<!-- Deactiveer standaard prefixing van deze module -->
<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % MijnML.prefixed "%NS.prefixed;" >

<!-- Declareer de eigenlijke namespace van deze module -->
<!ENTITY % MijnML.xmlns "http://www.voorbeeld.com/xmlns/mijnml" >

<!-- Declareer de standaard prefix voor deze module -->
<!ENTITY % MijnML.prefix "mijnml" >

<!-- Als de namespace van deze prefixed is -->
<![%MijnML.prefixed;[
  <!ENTITY % MijnML.pfx  "%MijnML.prefix;:" >
]]>
<!ENTITY % MijnML.pfx  "" >

<!-- Declareer een Parameter Entiteit (PE) die alle externe namespaces 
     definieert die gebruikt worden door deze module -->
<!ENTITY % MijnML.xmlns.extra.attrib "" >

<!-- Declareer een PE die de xmlns attributen definieert voor gebruik door MijnML. -->
<![%MijnML.prefixed;[
<!ENTITY % MijnML.xmlns.attrib
   "xmlns:%MijnML.prefix;  %URI.datatype;  #FIXED '%MijnML.xmlns;'
   %MijnML.xmlns.extra.attrib;"
>
]]>
<!ENTITY % MijnML.xmlns.attrib
   "xmlns   %URI.datatype;  #FIXED '%MijnML.xmlns;'
    %MijnML.xmlns.extra.attrib;"
>

<!-- Zorg ervoor dat de MijnML namespace attributen opgenomen worden op de XHTML
     attribuutset -->
<![%NS.prefixed;[
<!ENTITY % XHTML.xmlns.extra.attrib
    "%MijnML.xmlns.attrib;" >
]]>
<!ENTITY % XHTML.xmlns.extra.attrib
    ""
>
<!-- Declareer nu de element namen -->

<!ENTITY % MijnML.mijnelement.qname "%MijnML.pfx;mijnelement" >
<!ENTITY % MijnML.mijnanderelement.qname "%MijnML.pfx;mijnanderelement" >

Definieer vervolgens een module die de elementen en attributen definieert door gebruik te maken van de XHTML voorziene template.

<!-- ...................................................................... -->
<!-- Mijn Elementen Module ................................................... -->
<!-- file: mijnml-elements-1_0.mod

     PUBLIC "-//MIJN BEDRIJF//ELEMENTS XHTML MijnML Elements 1.0//EN"
     SYSTEM "http://voorbeeld.com/DTDs/mijnml-elements-1_0.mod"

     xmlns:mijnml="http://voorbeeld.com/DTDs/mijnml-1_0.dtd"
     ...................................................................... -->

<!-- Mijn Elementen Module

     mijnelement
     mijnanderelement

     Deze module heeft geen ander doel dan de structuur voorzien voor bepaalde 
     PCDATA inhoud.
-->

<!ELEMENT %MijnML.mijnelement.qname;
     ( #PCDATA | %MijnML.mijnanderelement.qname; )* >
<!ATTLIST %MijnML.mijnelement.qname;
     mijnattribute    CDATA   #IMPLIED
     %MijnML.xmlns.attrib;
>

<!ELEMENT %MijnML.mijnanderelement.qname; EMPTY >
<!ATTLIST %MijnML.mijnanderelement.qname;
      %MijnML.xmlns.attrib;
>

<!ENTITY % MijnML.img.mijnattr.qname "%MijnML.pfx;mijnattr" >
<!ATTLIST %img.qname;
      %MijnML.img.mijnattr.qname;   CDATA  #IMPLIED
      %MijnML.xmlns.attrib;
>

<!-- einde van mijnml-elements-1_0.mod -->

Bouw nu een inhoudsmodel omschrijving die de nieuwe elementen en attributen koppelt aan de andere XHTML elementen. Het volgende voorbeeld is gemodelleerd naar het XHTML Basic inhoudsmodel, maar is een volledig onafhankelijke inhoudsmodelmodule:

<!-- ...................................................................... -->
<!-- MijnML Model Module  ................................................... -->
<!-- file: mijnml-model-1.mod

     PUBLIC "-//MIJN BEDRIJF//ELEMENTS XHTML MijnML Model 1.0//EN"
     SYSTEM "http://voorbeeld.com/DTDs/mijnml-model-1_0.mod"

     xmlns:mijnml="http://www.voorbeeld.com/xmlns/mijnml"
     ...................................................................... -->

<!-- Definieer het inhoudsmodel voor Misc.extra -->
<!ENTITY % Misc.class
     "| %MijnML.mijnelement.qname; ">

<!-- ....................  Inline Elementen  ...................... -->

<!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; neemt alle inline elementen op,
     gebruikt als een component in mixes
-->
<!ENTITY % Inline.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %Anchor.class;
      %InlSpecial.class;"
>

<!-- %InlNoAnchor.class; neemt alle niet-anker inlines op,
     gebruikt als een component in mixes
-->
<!ENTITY % InlNoAnchor.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %InlSpecial.class;"
>

<!-- %InlNoAnchor.mix; neemt alle niet-anker inlines op
-->
<!ENTITY % InlNoAnchor.mix
     "%InlNoAnchor.class;
      %Misc.class;"
>

<!-- %Inline.mix; neemt alle inline elementen, inclusief %Misc.class; op
-->
<!ENTITY % Inline.mix
     "%Inline.class;
      %Misc.class;"
>

<!-- .....................  Block Elementen  ...................... -->

<!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; neemt alle block elementen op,
     gebruikt als een component in mixes
-->
<!ENTITY % Block.class
     "%BlkStruct.class;
      %BlkPhras.class;
      %BlkPres.class;
      %Block.extra;"
>

<!-- %Block.mix; neemt alle block elementen plus %Misc.class; op
-->
<!ENTITY % Block.mix
     "%Heading.class;
      | %List.class;
      | %Block.class;
      %Misc.class;"
>

<!-- ................  Alle Inhoudselementen  .................. -->

<!-- %Flow.mix; neemt alle tekstinhoud, block en inline, op
-->
<!ENTITY % Flow.mix
     "%Heading.class;
      | %List.class;
      | %Block.class;
      | %Inline.class;
      %Misc.class;"
>

<!-- speciaal inhoudsmodel voor pre element -->
<!ENTITY % pre.content
    "( #PCDATA
     | %Inline.class; )*"
>

<!-- einde van mijnml-model-1.mod -->

Gebruik tot slot de XHTML-voorziene template voor een nieuwe DTD, geschikt aangepast voor onze nieuwe opmaaktaal:

<!-- ....................................................................... -->
<!-- MIJNML DTD  ............................................................. -->
<!-- file: mijnml-1_0.dtd -->

<!-- Dit is de DTD driver voor mijnml 1.0.

     Gebruik a.u.b. deze formele publieke identificator om het te identificeren:

         "-//MIJN BEDRIJF//DTD XHTML MIJNML 1.0//EN"

     En deze namespace voor mijnml-unieke elementen:

         xmlns:mijnml="http://www.voorbeeld.com/xmlns/mijnml"
-->
<!ENTITY % XHTML.version  "-//MIJN BEDRIJF//DTD XHTML MIJNML 1.0//EN" >

<!-- gereserveerd voor gebruik met document profielen -->
<!ENTITY % XHTML.profile  "" >

<!-- Vertel het framework om onze gekwalificeerde names module te gebruiken als 
een extra qname driver -->
<!ENTITY % xhtml-qname-extra.mod
     SYSTEM "mijnml-qname-1.mod" >

<!-- Definieer het Inhoudsmodel voor het te gebruiken framework -->
<!ENTITY % xhtml-model.mod
     SYSTEM "mijnml-model-1.mod" >

<!-- Deactiveer bidirectionele tekst ondersteuning -->
<!ENTITY % XHTML.bidi  "IGNORE" >

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

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

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

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

<!-- Mijn Elementen Module   ........................................ -->
<!ENTITY % MijnML-elements.mod
     SYSTEM "mijnml-elements-1.mod" >
%MijnML-elements.mod;

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

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

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

E.5. Een nieuwe DTD gebruiken

Zodra een nieuwe DTD ontwikkeld is, kan het gebruikt worden in elk document. Een DTD gebruiken is zo eenvoudig als ernaar verwijzen in de DOCTYPE declaratie van een document:

<!DOCTYPE html SYSTEM "mijnml-1_0.dtd" >
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
<title>Een standaardvoorbeeld</title>
</head>
<body>
<p>Dit is inhoud in de XHTML namespace</p>
<mijnelement>
  Dit is inhoud in de SimpleML namespace.
  <mijnanderelement />
</mijnelement>
<p><img src="missing" alt="Missing image" mijnattr="value"/></p>
</body>
</html>

Het document kan ook de elementen buiten de XHTML namespace gebruiken door ze te prefixen:

<!DOCTYPE html SYSTEM "mijnml-1_0.dtd" [
  <!ENTITY % MijnML.prefixed "INCLUDE" >
]>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
<title>Een standaardvoorbeeld</title>
</head>
<body>
<p>Dit is inhoud in de XHTML namespace</p>
<mijnml:mijnelement>
  Dit is inhoud in de mijnml namespace.
  <mijnml:mijnanderelement />
</mijnml:mijnelement>
<p><img src="missing" alt="Missing image" mijnml:mijnattr="value" /></p>
</body>
</html>