E. Opracowywanie DTD ze zdefiniowanymi i rozszerzonymi modułami

Zawartość

E.1. Definiowanie dodatkowych atrybutów
E.2. Definiowanie dodatkowych elementów
E.3. Definiowanie modelu zawartości dla zestawu modułów
- E.3.1. Włączanie samodzielnego modułu do XHTML
- E.3.2. Mieszanie nowego modułu ze wszystkimi modułami XHTML

Ten dodatek ma charakter informacyjny.

Podstawowym celem definiowania modułów XHTML i ogólną metodyką modularyzacji jest ułatwianie opracowywania typów dokumentu opartych na XHTML. Te typy dokumentu mogą rozszerzać XHTML poprzez dołączanie dodatkowych możliwości (np. [SMIL]), mogą też definiować podzbiór XHTML w celu użycia na wyspecjalizowanym urządzeniu. Ten rozdział opisuje techniki, które projektanci typów dokumentu muszą użyć w celu wykorzystania implementacji tej architektury modularyzacji w DTD XML. Robi to poprzez zastosowanie technik modularyzacji XHTML w coraz bardziej złożony sposób, kończąc stworzeniem kompletnego typu dokumentu z całkowicie różnych modułów.

Zauważ, że w żadnym wypadku przykłady te nie wymagają modyfikacji encji plikowych modułów dostarczanych przez XHTML. Encje plikowe modułów XHTML są całkowicie sparametryzowane, można dzięki temu poprzez definicje w oddzielnych modułach i pliki sterownika dostosować do swych potrzeb definicję i model zawartości każdego z elementów oraz hierarchię każdego z elementów.

Pamiętaj też, że od większości użytkowników XHTML nie oczekuje się, by byli autorami DTD. Autorzy DTD, ogólnie rzecz biorąc, to ludzie definiujący wyspecjalizowane oznakowanie, które poprawi czytelność, uprości renderowanie dokumentu, czy ułatwi automatyczne przetwarzanie dokumentów, albo są projektantami oprogramowania klienckiego i muszą definiować wyspecjalizowane DTD dla swoich określonych klientów. Rozważ następujące przypadki:

Organizacja dostarcza zaprenumerowane informacje poprzez interfejs WWW. Organizacja ta przechowuje subskrybowane informacje w bazie danych opartej na XML. Jednym ze sposobów ekstrakcji tych informacji z bazy danych jest umieszczenie rekordów XML z bazy danych bezpośrednio w dokumencie XHTML. Choć możliwe jest jedynie zagnieżdżenie rekordów, organizacja może zdefiniować moduł DTD opisujący te rekordy, przypisać ten moduł do DTD XHTML i tym samym stworzyć kompletne DTD dla stron. Organizacja może następnie uzyskać dostęp do danych wewnątrz nowych elementów poprzez obiektowy model dokumentu [DOM], dokonać walidacji dokumentów, dodać definicje stylów dla elementów przy użyciu kaskadowych arkuszy stylów [CSS2], itd. Definiując strukturę danych i tworząc DTD przy użyciu działań opisanych w tym rozdziale organizacja może w pełni czerpać korzyści ze stosowania XML.
Twórca internetowego oprogramowania klienckiego projektuje wyspecjalizowane urządzenie. Będzie ono obsługiwało jedynie podzbiór XHTML, a dostęp do Internetu bedzie zawsze uzyskiwało porzez serwer proxy, który waliduje zawartość przed przekazaniem jej do klienta (by zminimalizować konieczność obsługi błędów przez klienta). W celu upewnienia się, że zawartość jest poprawna strukturalnie, wspomniany twórca konstruuje DTD będące podzbiorem XHTML, stosując działania opisane w tym rozdziale. Następnie nowe DTD stosowane jest na serwerach proxy i w urządzeniach, jest ono też udostępniane innym twórcom, by mogli walidować zawartość przed jej udostępnieniem. Stosując kilka prostych kroków twórca klientów może używać architektury zdefiniowanej w tym dokumencie, by ogromnie zmniejszyć koszty opracowywania DTD oraz zapewnić pełne obsługiwanie przez te klienty podzbioru XHTML, który został przez niego włączony.

E.1. Definiowanie dodatkowych atrybutów

W niektórych wypadkach rozszerzenie XHTML może sprowadzać się do dodania atrybutów. Atrybuty powinny być dodane do elementu po prostu poprzez określenie dodatkowego wykazu ATTLIST dla tego elementu, na przykład:

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

doda atrybut "myattr" z opcjonalnym przedrostkiem zdefiniowanym przez "%MyModule.pfx", z wartością typu CDATA, do elementu "a". Będzie to działać, ponieważ XML zezwala na definiowanie lub rozszerzanie wykazu atrybutów w dowolnym miejscu w DTD. Omówienie kwestii nazw kwalifikowanych i przedrostków przestrzeni nazw znajduje się w części Definiowanie przestrzeni nazw modułu.

Naturalnie dodanie atrybutu do DTD nie oznacza, że w jakimkolwiek kliencie zdefiniowane jest jakieś nowe zachowanie. Jednakże twórcy treści powinni używać dodatkowych atrybutów w celu przechowywania informacji, do których poprzez obiektowy model dokumentu mają dostęp skojarzone skrypty (na przykład).

E.2. Definiowanie dodatkowych elementów

Definiowanie dodatkowych elementów jest tylko trochę bardziej skomplikowane od definiowania dodatkowych atrybutów. W zasadzie autorzy DTD powinni napisać deklarację dodatkowego elementu dla każdego z elementów:

<!-- W podmodule nazw kwalifikowanych -->
<!ENTITY % MyModule.myelement.qname  "%MyModule.pfx;myelement" >
<!ENTITY % MyModule.myotherelement.qname  "%MyModule.pfx;myotherelement" >

<!-- W podmodule deklaracji -->
<!ELEMENT %MyModule.myelement.qname; 
           ( #PCDATA | %MyModule.myotherelement.qname; )* >
<!ATTLIST %MyModule.myelement.qname;
          myattribute    CDATA    #IMPLIED
>

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

Po zdefiniowaniu elementów, muszą one być włączone do modelu zawartości. Strategiami włączania nowych elementów lub zbiorów elementów do modelu zawartości zajmuje się następna część dodatku.

E.3. Definiowanie modelu zawartości dla zestawu modułów

Choć model zawartości modułów XHTML jest w pełni sparametryzowany, autorzy DTD moga modyfikować model zawartości dla każdego elementu w każdym module. Szczegóły interfejsu modułu DTD są zdefiniowane w dodatku Konstruowanie modułów DTD. Zasadniczo istnieją dwa sposoby podejścia do tej modyfikacji:

Powtórnie zdefiniuj encję parametryczną ".content" dla każdego elementu.
Powtórnie zdefiniuj jedną lub więcej z globalnych encji modelu zawartości (normalnie poprzez encję parametryczną ".extras").

Obrana strategia zależna będzie od natury łączonych modułów i elementów. Reszta niniejszej części opisuje techniki łączenia dwu różnych klas modułów.

E.3.1. Włączanie samodzielnego modułu do XHTML

Gdy moduł (pamiętaj — moduł może być też zestawem innych modułów) zawiera elementy, z których wszystkie w swoich modelach zawartości odwołują się do siebie, jest on nazywany "wewnętrznie kompletnym". Jako taki, moduł ten może być używany samodzielnie; (na przykład możesz zdefiniować DTD będący po prostu tym modułem i użyć jeden z jego elementów jako element główny). Włączanie takiego modułu do XHTML jest trzyetapowym procesem:

Zdecyduj, który/które element(y) może/mogą pełnić rolę korzeni(a) w nowym module.
Zdecyduj, w którym miejscu drzewa zawartości XHTML elementy te powinny być przyłączone.
Następnie dla każdego miejsca przyłączenia w drzewie zawartości dodaj element(y) główny/główne do definicji zawartości dla elementów XHTML.

Rozważ przyłączenie elementów zdefiniowanych powyżej. W tamtym przykładzie element myelement jest korzeniem. By przyłączyć ten element pod element img i tylko element img, z XHTML, dobrze jest postąpić następująco:

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

DTD zdefiniowane wraz z tym modelem zawartości pozwoli na zastosowanie fragmentu dokumentu podobnego do tego:

<img src="...">
<myml:myelement>To jest zawartość elementu zdefiniowanego lokalnie</myml:myelement>
</img>

Ważne, by zauważyć, że normalnie model zawartości elementu img to EMPTY. Dodając element myelement do tego modelu zawartości tak naprawdę po prostu zamieniamy EMPTY na myelement. W przypadku innych elementów, które już mają zdefiniowane modele zawartości, dodanie elementu będzie wymagać także odświeżenia istniejącego modelu zawartości oprócz elementu myelement.

E.3.2. Mieszanie nowego modułu ze wszystkimi modułami XHTML

Rozszerzając powyższy przykład, przyłączenie tego modułu wszędzie tam, gdzie dozwolona jest grupa modelów zawartości %Flow.mix będzie wymagało czegoś w tym stylu:

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

Gdy klasa modelów zawartości %Misc.extra jest używana w encji parametrycznej %Misc.class, a ta encja parametryczna jest używana we wszystkich modułach XHTML, nowy moduł stanie się dostępny w całym rozszerzonym typie dokumentu XHTML.

E.4. Tworzenie nowego DTD

Dotychczas przykłady w tej części opisywały metody rozszerzania XHTML i modelu zawartości XHTML. Gdy jest to już zrobione, następnym etapem będzie zebranie modułów składających się na DTD w pojedynczym sterowniku DTD, przyłączając nowe definicje odpowiednio nadpisujące i uzupełniające podstawowe definicje XHTML.

E.4.1. Tworzenie prostego DTD

Korzystając z banalnego przykładu przedstawionego powyżej można zdefiniować nowe DTD, które używa i całkiem łatwo rozszerza moduły XHTML. Najpierw zdefiniuj w module nowe elementy i ich model zawartości:

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

<!-- Zadeklaruj encję parametryczną (EP), która definiuje wszystkie zewnętrzne
     przestrzenie nazw używane przez ten moduł -->

<!ENTITY % SimpleML.xmlns.attrib
  "%NS.decl.attrib;"
>

<!-- Ustaw EP, która jest używana w każdej deklaracji ATTLIST w tym module.
     NS.prefixed.attrib jest inicjalizowana w module xhtml-qname, a
     SimpleML.ns.noprefix.attrib jest inicjalizowana w pliku sterownika DTD
     SimpleML. -->

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

<!-- Dodaj nasze elementy do modelu zawartości XHTML -->
<!ENTITY % Misc.class
     "| %SimpleML.element.qname;" >

<!-- Teraz wprowadź model zawartości XHTML Basic -->
<!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;

Następnie zdefiniuj sterownik DTD dla nowego języka:

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

<!-- Wprowadź typy danych XHTML -->
<!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;

<!-- Zadeklaruj rzeczywistą przestrzeń nazw tego modułu -->
<!ENTITY % SimpleML.xmlns "http://www.example.com/xmlns/simpleml1" >

<!-- Ustaw domyślne niedodawanie przedrostków w nowym module -->
<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % SimpleML.prefixed "%NS.prefixed;" >

<!-- Domyślny przedrostek dla elements i atrybutów modułu -->
<!ENTITY % SimpleML.prefix "simpleml" >

<!-- Jeśli do przestrzeni nazw tego modułu dodawany jest przedrostek -->
<![%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;"
>
<!-- Ustaw model zawartości dla naszego języka -->
<!ENTITY % xhtml-model.mod
     SYSTEM "simpleml-model-1.mod" >
<!-- Rozwiń DTD XHTML Basic, by to wszystko zrobił -->
<!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;

Używając tego DTD istnieje możliwość włączenia używania przedrostków przestrzeni nazw XML. W takim wypadku początek dokumentu używającego tego nowego DTD mógłby wyglądać tak:

<!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>Przykład z użyciem domyślnych ustawień</title>
</head>
<body>
<p>To jest zawartość będąca w przestrzeni nazw XHTML</p>
<simpleml:element>
  To jest zawartość w przestrzeni nazw SimpleML.
  <simpleml:otherelement />
</simpleml:element>
<p><img src="missing" alt="Missing image" simpleml:myattr="value"/></p>
</body>
</html>

E.4.2. Tworzenie DTD poprzez rozszerzanie XHTML

Teraz mamy sytuację, w której kompletny, dodatkowy i złożony moduł jest dodany do XHTML (lub do pozbioru XHTML). W gruncie rzeczy jest on taki sam, jak w powyższym trywialnym przykładzie, jedyną różnicą jest to, że moduł dodawany jest dołączany do DTD poprzez odwołanie, zamiast bezpośredniego dołączenia nowych definicji do DTD.

Jednym z takich złożonych modułów jest DTD dla [MATHML]. W celu połączenia MathML i XHTML w pojedynczy DTD, autor mógłby po prostu zadecydować, gdzie zawartość MathML powinna być dopuszczalna w dokumencie i dodać element główny MathML modelu zawartości w tym miejscu. Najpierw zdefiniuj moduł modelu zawartości rozwijający DTD MathML i łączący go z modelem zawartości:

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

Następnie zdefiniuj sterownik DTD, który zidentyfikuje nasz nowy moduł modelu zawartości jako model zawartości dla DTD i przekaże przetwarzanie do sterownika XHTML 1.1 (na przykład):

<!-- plik: 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. Tworzenie DTD poprzez usuwanie i zamienianie modułów XHTML

Innym sposobem, w który autorzy DTD mogą użyć modułów XHTML jest zdefiniowanie DTD będącego podzbiorem typu dokumentu rodziny XHTML (ponieważ, na przykład, tworzą urządzenia lub oprogramowanie które obsługuje tylko podzbiór XHTML). Jest to tylko trochę bardziej skomplikowane niż poprzedni przykład. Oto podstawowe kroki, które musisz wykonać:

Weź za podstawę nowego typu dokumentu DTD rodziny XHTML (my będziemy używać XHTML 1.1).
Wybierz moduły do usunięcia z tego DTD.
Zdefiniuj nowe DTD, które zignoruje (za pomocą słowa kluczowego IGNORE) te moduły.
Wprowadź jakieś nowe moduły.

Rozważ na przykład urządzenie używające modułów XHTML, ale bez formularzy i tabel. DTD dla takiego urządzenia wyglądałoby tak:

<!-- plik: xhtml-simple.dtd -->
<!ENTITY % xhtml-form.module "IGNORE" >
<!ENTITY % xhtml-table.module "IGNORE" >
<!ENTITY % xhtml-table.module "IGNORE" >
<!-- Wprowadź modeuł prostych tabel -->
<!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;

Zauważ, że właściwie nie następuje tu modyfikacja modelu zawartości dla DTD XHTML 1.1. Jednak w sytuacji, gdy XML ignoruje elementy w modelach zawartości, które są niezdefiniowane, elementy formularzy i tabel są automatycznie usuwane z tego modelu.

E.4.4. Tworzenie nowego DTD

Niektórzy autorzy DTD mogą chcieć zacząć od zera, używając ogólnych zasad modularyzacji XHTML jako narzędzia do konstruowania nowego języka znaczników. Język ten musi składać się z minimalnie wymaganych modułów z XHTML. Może także zawierać inne zdefiniowane w XHTNL moduły czy jakiekolwiek inne moduły, które autor chce włączyć. W tym przykładzie weźmiemy wymagane moduły XHTML, dodamy kilka modułów zdefiniowanych w XHTML i dodamy też moduł, który zdefiniowaliśmy powyżej.

Pierwszym krokiem jest użycie dostarczanego wraz z XHTML szablonu dla nowego modułu nazw kwalifikowanych, zmodyfikowanego w celu zdefiniowania nazw kwalifikowanych i przestrzeni nazw dla naszych nowych elementów.

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

<!-- Wprowadź typy danych - do deklarowania atrybutów xmlns używamy
     encji parametrycznej URI.datatype. -->
<!ENTITY % MyML-datatypes.mod
         PUBLIC "-//W3C//ENTITIES XHTML Datatypes 1.0//EN"
         "http://www.w3.org/TR/xhtml-modularization/DTD/xhtml-datatypes-1.mod" >
%MyML-datatypes.mod;

<!-- Ustaw domyślne niedodawanie przedrostków w tym module -->
<!ENTITY % NS.prefixed "IGNORE" >
<!ENTITY % MyML.prefixed "%NS.prefixed;" >

<!-- Zadeklaruj rzeczywistą przestrzeń nazw tego modułu -->
<!ENTITY % MyML.xmlns "http://www.example.com/xmlns/myml" >

<!-- Zadeklaruj domyślny przedrostek dla tego modułu -->
<!ENTITY % MyML.prefix "myml" >

<!-- Jeśli do przestrzeni nazw tego modułu dodawany jest przedrostek -->
<![%MyML.prefixed;[
  <!ENTITY % MyML.pfx  "%MyML.prefix;:" >
]]>
<!ENTITY % MyML.pfx  "" >

<!-- Zadeklaruj encję parametryczną (EP), która definiuje wszystkie zewnętrzne
     przestrzenie nazw używane przez ten moduł -->
<!ENTITY % MyML.xmlns.extra.attrib "" >

<!-- Zadeklaruj EP definiującą atrybuty xmlns mające być używane przez MyML. -->
<![%MyML.prefixed;[
<!ENTITY % MyML.xmlns.attrib
   "xmlns:%MyML.prefix;  %URI.datatype;  #FIXED '%MyML.xmlns;'
   %MyML.xmlns.extra.attrib;"
>
]]>
<!ENTITY % MyML.xmlns.attrib
   "xmlns   %URI.datatype;  #FIXED '%MyML.xmlns;'
    %MyML.xmlns.extra.attrib;"
>

<!-- Upewnij się, że atrybuty przestrzeni nazw MyML są zawarte w zestawie
     atrybutów XHTML -->
<![%NS.prefixed;[
<!ENTITY % XHTML.xmlns.extra.attrib
    "%MyML.xmlns.attrib;" >
]]>
<!ENTITY % XHTML.xmlns.extra.attrib
    ""
>
<!-- Teraz zadeklaruj nazwy elementów -->

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

Następnie zdefiniuj moduł definiujący elementy i atrybuty przy użyciu dostarczanego wraz z XHTML szablonu.

<!-- ...................................................................... -->
<!-- My Elements Module ................................................... -->
<!-- plik: 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"
     ...................................................................... -->

<!-- Moduł My Elements

     myelement
     myotherelement

     Jedynym zadaniem tego modułu jest dostarczenie struktury
     dla zawartości typu PCDATA.
-->

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

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

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

<!-- koniec pliku myml-elements-1_0.mod -->

Teraz utwórz opis modelu zawartości, który przyłącza nowe elementy i atrybuty do innych elementów XHTML. Następujący przykład odpowiada modelowi zawartości XHTML Basic, jest jednak kompletnym, niezależnym modułem modelu zawartości:

<!-- ...................................................................... -->
<!-- MyML Model Module  ................................................... -->
<!-- plik: 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"
     ...................................................................... -->

<!-- Zdefiniuj model zawartości dla Misc.extra -->
<!ENTITY % Misc.class
     "| %MyML.myelement.qname; ">

<!-- ..................  Elementy wewnątrzwierszowe  .................... -->

<!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; zawiera wszystkie elementy wewnątrzwierszowe
     używane jako składniki w różnych połączeniach
-->
<!ENTITY % Inline.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %Anchor.class;
      %InlSpecial.class;"
>

<!-- %InlNoAnchor.class; zawiera wszystkie niekotwicowe elementy wewnątrzwierszowe
     używane jako składniki w różnych połączeniach
-->
<!ENTITY % InlNoAnchor.class
     "%InlStruct.class;
      %InlPhras.class;
      %InlPres.class;
      %InlSpecial.class;"
>

<!-- %InlNoAnchor.mix; zawiera wszystkie niekotwicowe elementy wewnątrzwierszowe
-->
<!ENTITY % InlNoAnchor.mix
     "%InlNoAnchor.class;
      %Misc.class;"
>

<!-- %Inline.mix; zawiera wszystkie elementy wewnątrzwierszowe, łącznie z %Misc.class;
-->
<!ENTITY % Inline.mix
     "%Inline.class;
      %Misc.class;"
>

<!-- .....................  Elementy blokowe  ...................... -->

<!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; zawiera wszystkie elementy blokowe
     używane jako składniki w różnych połączeniach
-->
<!ENTITY % Block.class
     "%BlkStruct.class;
      %BlkPhras.class;
      %BlkPres.class;
      %Block.extra;"
>

<!-- %Block.mix; zawiera wszystkie elementy blokowe plus %Misc.class;
-->
<!ENTITY % Block.mix
     "%Heading.class;
      | %List.class;
      | %Block.class;
      %Misc.class;"
>

<!-- ..............  Wszystkie elementy zawartości  ................ -->

<!-- %Flow.mix; zawiera wszystkie elementy zawartości tekstowej,
     blokowe i wewnątrzwierszowe -->
<!ENTITY % Flow.mix
     "%Heading.class;
      | %List.class;
      | %Block.class;
      | %Inline.class;
      %Misc.class;"
>

<!-- specjalny model zawartości dla elementu pre -->
<!ENTITY % pre.content
    "( #PCDATA
     | %Inline.class; )*"
>

<!-- koniec pliku myml-model-1.mod -->

Na koniec użyj dostarczanego wraz z XHTML szablonu dla nowego DTD, zmodyfikowanego w sposób odpowiedni dla naszego nowego języka znaczników:

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

<!-- To jest sterownik DTD dla myml 1.0.

     Do identyfikacji proszę użyć tego formalnego identyfikatora publicznego:

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

     To jest przestrzeń nazw dla elementów właściwych tylko dla myml:

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

<!-- zarezerwowane do użycia z profilami dokumentu -->
<!ENTITY % XHTML.profile  "" >

<!-- Nakaż zasadom ogólnym używanie naszego modułu nazw kwalifikowanych
     jako dodatkowego sterownika nazw kwalifikowanych
-->
<!ENTITY % xhtml-qname-extra.mod
     SYSTEM "myml-qname-1.mod" >

<!-- Zdefiniuj Model Zawartości dla użytku zasad ogólnych -->
<!ENTITY % xhtml-model.mod
     SYSTEM "myml-model-1.mod" >

<!-- Wyłącz obsługę tekstu dwukierunkowego -->
<!ENTITY % XHTML.bidi  "IGNORE" >

<!-- Wprowadź zasady ogólne XHTML -->
<!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;

<!-- Moduł Basic Text (wymagany)  ............................... -->
<!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;

<!-- Moduł Hypertext (wymagany) ................................. -->
<!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;

<!-- Moduł Lists (wymagany)  .................................... -->
<!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;

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

<!-- Moduł XHTML Images  ........................................ -->
<!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;

<!-- Moduł Document Metainformation  ............................ -->
<!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;

<!-- Moduł Document Structure (wymagany)  ....................... -->
<!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. Używanie nowego DTD

Nowo opracowane DTD może być teraz używane w dowolnym dokumencie. Używanie takiego DTD jest bardzo proste — wystarczy odwołać się do niego w deklaracji DOCTYPE dokumentu:

<!DOCTYPE html SYSTEM "myml-1_0.dtd" >
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
<title>Przykład z użyciem domyślnych ustawień</title>
</head>
<body>
<p>To jest zawartość w przestrzeni nazw XHTML </p>
<myelement>
  To jest zawartość w przestrzeni nazw SimpleML.
  <myotherelement />
</myelement>
<p><img src="missing" alt="Missing image" myattr="value"/></p>
</body>
</html>

Dokument ten może też używać elementów spoza przestrzeni nazw XHTML poprzez dodanie do nich przedrostka:

<!DOCTYPE html SYSTEM "myml-1_0.dtd" [
  <!ENTITY % MyML.prefixed "INCLUDE" >
]>
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
<title>Przykład z użyciem domyślnych ustawień</title>
</head>
<body>
<p>To jest zawartość w przestrzeni nazw XHTML</p>
<myml:myelement>
  To jest zawartość w przestrzeni nazw myml.
  <myml:myotherelement />
</myml:myelement>
<p><img src="missing" alt="Missing image" myml:myattr="value" /></p>
</body>
</html>

Strona główna

Ostatnia modyfikacja: 17 sierpnia 2005