Topics

(Auszug aus "DITA - Der neue Standard für Technische Dokumentation" von Johannes Hentrich)

Werden Topics spezialisiert, so spricht man von einer strukturellen Spezialisierung, da neue Informationsstrukturen erzeugt werden. Topics können wie folgt spezialisiert werden:

Neue Topictypen werden aus dem generischen Topictyp erzeugt. Die drei in DITA bekannten Topictypen „Aufgabe“, „Konzept“ und „Referenz“ sind auf diese Weise entstanden.
Aus den bekannten Topictypen werden modifizierte Topictypen erzeugt. Der in DITA 1.1 neu eingeführte Topictyp „Glossar“ ist eine Spezialisierung des bereits vorhandenen Topictyps „Konzept“.

In der Vorgehensweise unterscheiden sich die beiden Formen der Spezialisierung nicht. In beiden Fällen wird von einer bereits vorhandenen Informationsstruktur ausgegangen, die zur Spezialisierung herangezogen wird.

Im folgenden Beispiel wird die Topic-Spezialisierung für den Topictyp „Konzept“ vorgestellt. Dabei wird ein Topictyp entwickelt, in den Inhalte von Supportanfragen aufgenommen werden können. Danach wird gezeigt, wie die XSLT-Stylesheets für die Spezialisierung angepasst werden können.

Beispiel für eine Topic-Spezialisierung

Am Anfang einer Topic-Spezialisierung steht die Entwicklung eines Inhaltsmodells für den neuen Topictyp. Mit dem Inhaltsmodell werden die einzelnen Elemente definiert. Beachten Sie, dass das Inhaltsmodell des spezialisierten Topictyps restriktiver sein muss, als das ursprüngliche Inhaltsmodell. Informationen, welche Regeln bei der Erstellung eines Inhaltsmodells zu befolgen sind, erhalten Sie in Flexible Erweiterbarkeit.

Das aus dem Inhaltsmodell resultierende Modell-Dokument wird nach Abschluss der Spezialisierung dazu verwendet, die durchgeführte Topic-Spezialisierung zu testen.

Ein Modell-Dokument für die Erfassung und die Beantwortung einer Support-Anfrage könnte wie folgt aufgebaut sein:

<?xml version="1.0"?>
<!DOCTYPE support SYSTEM "support.dtd">
<support id="support-id">
    <support-frage>Unter welchen Telefonnummern ist der Support erreichbar?</support-frage>
    <support-kurze-antwort>
        <p>Unter der Nummer <b>12345</b> sind wir jederzeit für Sie da!</p>
    </support-kurze-antwort>
    <support-lange-antwort>
        <p>Außerdem können Sie uns per E-Mail und per Fax erreichen</p>
    </support-lange-antwort>
</support>

Das Wurzel-Element des neuen Topictyps ist das <support>-Element. Dies hat eine eindeutige ID. Die Support-Anfrage wird mit dem <support-frage>-Element aufgenommen. Eine kurze Antwort wird im <support-kurze-antwort>-Element erfasst. Dieses Element soll erforderlich sein. Eine lange, ausführlichere Antwort wird im <support-lange-antwort>-Element abgelegt.

Die folgende Tabelle zeigt, aus welchen Elementen des Topictyps „Konzept“ die Elemente des Topictyps „Support“ spezialisiert werden sollen.

concept.dtd	support.dtd
<concept>	<support>
<title>	<support-frage>
<shortdesc>	<support-kurze-antwort>
<conbody>	<support-lange-antwort>

Tabelle: Spezialisierte Elemente für den Topictyp „Support“

Folgende Schritte sind notwendig, um eine Topic-Spezialisierung durchführen zu können:

Erstellen Sie eine Mantel-DTD für den neuen Topictyp.
Erstellen Sie eine mod-Datei, in der die Elemente des neuen Topictyps definiert sind.

Der erste Schritt bei einer Topic-Spezialisierung besteht darin, eine Mantel-DTD für den neuen Topictyp zu erstellen. Der einfachste Weg, eine neue Mantel-DTD für eine Topic-Spezialisierung zu erstellen, besteht darin, eine bestehende DTD-Datei zu kopieren und diese gemäß Ihren Anforderungen anzupassen. In der neuen Mantel-DTD können Sie Deklarationen hinzufügen oder Deklarationen, die Sie nicht benötigen, entfernen. Die Erstellung einer Mantel-DTD wird auch als „Integration“ bezeichnet.

Gehen Sie bei der Erstellung einer Mantel-DTD für den Topictyp „Support“ wie folgt vor:

Erstellen Sie eine Kopie der concept.dtd und vergeben Sie der Kopie den neuen Namen support.dtd.
Entfernen Sie alle Referenzen zu mod-Dateien und ent-Dateien, die für den Topictyp nicht benötigt werden.
Welche Referenzen zu den mod-Dateien und ent-Dateien entfernt werden, hängt von dem Inhaltsmodell des Modell-Dokuments ab. In diesem Beispiel seien nur die highlighting-Domain und die indexing-Domain verwendet.
Ersetzen Sie den Eintrag

 <!ENTITY % concept-info-types "concept" >

durch den Eintrag

 <!ENTITY % support-info-types "no-topic-nesting" >

Fügen Sie im TOPIC ELEMENT INTEGRATION-Abschnitt den folgenden Eintrag hinzu:

<!ENTITY % support-typemod SYSTEM "support.mod" >
%support-typemod;

Das ist die Referenz zur mod-Datei support.mod, die im zweiten Schritt der Topic-Spezialisierung erstellt wird. In der support-mod-Datei sind die spezialisierten Elemente des Topictyps „Support“ definiert.

Mit den in DITA üblichen Überschriften in DTDs sieht dann die support.dtd-Datei wie folgt aus:

<!-- ================================================= -->
<!-- HEADER  -->
<!-- ================================================= -->
<!-- MODULE: Support -->
<!-- VERSION: 1.0 -->
<!-- DATE: Mai 2008 -->
<!-- ================================================= -->
<!-- ================================================= -->
<!-- DOMAIN ENTITY DECLARATIONS -->
<!-- ================================================ -->
<!ENTITY % hi-d-dec PUBLIC "-//OASIS//ENTITIES DITA Highlight Domain//EN" "highlightDomain.ent" >
%hi-d-dec;
<!ENTITY % indexing-d-dec PUBLIC "-//OASIS//ENTITIES DITA Indexing Domain//EN" "indexingDomain.ent" >
%indexing-d-dec;
<!-- ================================================= -->
<!-- DOMAIN ATTRIBUTE DECLARATIONS -->
<!-- ================================================= -->
<!-- ================================================= -->
<!-- DOMAIN EXTENSIONS ->
<!-- ================================================= -->
<!ENTITY % pre "pre | %pr-d-pre; | %sw-d-pre; | %ui-d-pre;" >
<!ENTITY % keyword "keyword | %pr-d-keyword; | %sw-d-keyword; | %ui-d-keyword;" >
<!ENTITY % ph "ph | %pr-d-ph; | %sw-d-ph; | %hi-d-ph; | %ui-d-ph;" >
<!ENTITY % fig "fig | %pr-d-fig; | %ut-d-fig;" >
<!ENTITY % dl "dl | %pr-d-dl;" >
<!ENTITY % index-base "index-base | %indexing-d-indexbase;" >
<!-- ================================================= -->
<!-- DOMAIN ATTRIBUTE EXTENSIONS -->
<!-- ================================================= -->
<!ENTITY % props-attribute-extensions "" >
<!ENTITY % base-attribute-extensions "" >
<!-- ================================================ -->
<!-- TOPIC NESTING OVERRIDE -->
<!-- ================================================= -->
<!ENTITY % support-info-types "no-topic-nesting">
<!-- ============================= =================== -->
<!-- DOMAINS ATTRIBUTE OVERRIDE -->
<!-- ================================================= -->
<!ENTITY included-domains "&hi-d-att; &indexing-d-att;" >
<!-- ================================================= -->
<!-- TOPIC ELEMENT INTEGRATION -->
<!-- ================================================= -->
<!ENTITY % topic-type PUBLIC "-//OASIS//ELEMENTS DITA Topic//EN" "topic.mod2 >
%topic-type;
<!ENTITY % concept-typemod PUBLIC "-//OASIS//ELEMENTS DITA Concept//EN" "concept.mod" >
%concept-typemod;
<!ENTITY % support-typemod SYSTEM "support.mod" >
%support-typemod;
<!-- ================================================= -->
<!-- DOMAIN ELEMENT INTEGRATION -->
<!-- ================================================= -->
<!ENTITY % hi-d-def PUBLIC "-//OASIS//ELEMENTS DITA Highlight Domain//EN" "highlightDomain.mod" >
%hi-d-def;
<!ENTITY % indexing-d-def PUBLIC "-//OASIS//ELEMENTS DITA Indexing Domain//EN" "indexingDomain.mod" >
%indexing-d-def;
<!-- ============= End Support DTD ================== -->

Im zweiten Schritt einer Topic-Spezialisierung wird eine mod-Datei erstellt, in der die spezialisierten Elemente definiert werden. Da der Topictyp „Support“ aus dem Topictyp „Konzept“ spezialisiert wird, besteht der einfachste Weg zur Erstellung einer mod-Datei darin, eine Kopie der concept.mod-Datei zu erstellen und diese dann zu bearbeiten.

Gehen Sie bei der Erstellung der mod-Datei wie folgt vor:

Erstellen Sie eine Kopie der concept.mod-Datei und vergeben Sie der Kopie den neuen Namen support.mod.
Ersetzen Sie den Eintrag

 <!ENTITY % concept-info-types "%info-types;">

durch den Eintrag

 <!ENTITY % support-info-types "no-topic-nesting">

Ersetzen Sie die <concept>-Element-Deklaration

<!ELEMENT concept ((%title;), (%titlealts;)?, (%shortdesc; | %abstract;)?, (%prolog;)?, (%conbody;)?, (%related-links;)?, (%concept-info-types;)*) >

durch die <support>-Element-Deklaration

<!ELEMENT support ((%support-frage;), (%titlealts;)?, (%support-kurze-antwort;), (%prolog;)?, (%support-lange-antwort;)?, (%related-links;)?, (%concept-info-types;)*) >

In diesem Inhaltsmodell ist das <support-kurze-antwort>-Element als Pflichtfeld definiert. Damit ist das Inhaltsmodell restriktiver als das Inhaltsmodell des <concept>-Elements, da ein optionales Element durch ein erforderliches Element ersetzt wird.

Ersetzen Sie die Definition der Attribute für das <concept>-Element

<!ATTLIST concept    
    id ID #REQUIRED
    conref CDATA #IMPLIED
    %select-atts;
    %localization-atts;
    %arch-atts;
    outputclass
    CDATA #IMPLIED
    domains CDATA "&included-domains;" >

durch die Definition der Attribute für das <support>-Element

<!ATTLIST support    
    id ID #REQUIRED
    conref CDATA #IMPLIED
    %select-atts;
    %localization-atts;
    %arch-atts;
    outputclass
    CDATA #IMPLIED
    domains CDATA "&included-domains;" >

Ersetzen Sie die <conbody>-Element-Deklaration

 <!ELEMENT conbody ((%body.cnt;)*,(%section;|%example;)*) >

durch die <support-lange-antwort>-Element-Deklaration

 <!ELEMENT support-lange-antwort ((%body.cnt;)*, (%section;|%example;)* )>

Ersetzen Sie die Definition der Attribute für das <conbody>-Element

<!ATTLIST conbody    
    %id-atts;
    %localization-atts;
    base CDATA #IMPLIED
    %base-attribute-extensions;
    outputclass
    CDATA #IMPLIED>

durch die Definition der Attribute für das <support-lange-antwort>-Element

<!ATTLIST support-lange-antwort    
    %id-atts;
    %localization-atts;
    base CDATA #IMPLIED
    %base-attribute-extensions;
    outputclass
    CDATA #IMPLIED>

Kopieren Sie aus der commonElements.mod-Datei die <title>-Element-Deklaration und die Definition der Attribute für das <title>-Element in den ELEMENT DECLARATIONS-Abschnitt der support.mod-Datei.
Ersetzen Sie sowohl in der <title>-Element-Deklaration als auch in der Definition der Attribute für das <title>-Element title durch support-frage.

<!ELEMENT support-frage (%title.cnt;)* >

<!ATTLIST support-frage    
    %id-atts;
    %localization-atts;
    base CDATA #IMPLIED
    %base-attribute-extensions;
    outputclass
    CDATA #IMPLIED>

Kopieren Sie aus der commonElements.mod-Datei die <shortdesc>-<Element-Deklaration und die Definition der Attribute für das <span class="important"><shortdesc>-Element in den ELEMENT DECLARATIONS-Abschnitt der support.mod-Datei.
Ersetzen Sie sowohl in der <shortdesc>-Element-Deklaration als auch in der Definition der Attribute für das <shortdesc>-Element shortdesc durch support-kurze-antwort.

<!ELEMENT support-kurze-antwort (%title.cnt;)* >    

<!ATTLIST support-kurze-antwort
    %univ-atts;
    outputclass
    CDATA #IMPLIED>

Damit sind die neu spezialisierten Elemente <support>, <support-frage>, <support-kurze-antwort> und <support-lange-antwort> definiert.

Definieren Sie im ELEMENT NAME ENTITIES-Abschnitt die Parameter-Entitäten der spezialisierten Elemente:

<!ENTITY % support "support">
<!ENTITY % support-lange-antwort "support-lange-antwort">
<!ENTITY % support-kurze-antwort "support-kurze-antwort">
<!ENTITY % support-frage "support-frage">

Definieren Sie im SPECIALIZATION ATTRIBUTE DECLARATIONS-Abschnitt die class-Attribute für die spezialisierten Elemente:

<!ATTLIST support %global-atts;class CDATA "- topic/topic concept/concept support/support">

<!ATTLIST support-kurze-antwort %global-atts; class CDATA "- topic/shortdesc support/support-kurze-antwort">

<!ATTLIST support-lange-antwort %global-atts; class CDATA "- topic/body concept/conbody support/support-lange-antwort">

<!ATTLIST support-frage %global-atts; class CDATA "- topic/title support/support-frage">

Damit sieht die support.mod-Datei mit den in DITA üblichen Überschriften wie folgt aus:

<!-- ================================================= -->
<!-- HEADER -->
<!-- ================================================= -->
<!-- MODULE: Support -->
<!-- VERSION: Mai 2008 -->
<!-- ================================================= -->
<!-- ================================================= -->
<!-- ARCHITECTURE ENTITIES -->
<!-- ================================================= -->
<!ENTITY % DITAArchNSPrefix,"ditaarch" >
<!ENTITY % arch-atts " xmlns:%DITAArchNSPrefix; CDATA #FIXED‚http://dita.oasis-open.org/architecture/2005/‘ %DITAArchNSPrefix;:DITAArchVersion CDATA ‚1.1‘" >
<!-- ================================================= -->
<!-- SPECIALIZATION OF DECLARED ELEMENTS -->
<!-- ================================================= -->
<!ENTITY % support-info-types "no-topic-nesting">
<!-- ================================================= -->
<!-- ELEMENT NAME ENTITIES -->
<!-- ================================================= -->
<!ENTITY % support "support" >
<!ENTITY % support-lange-antwort "support-lange-antwort" >
<!ENTITY % support-kurze-antwort "support-kurze-antwort" >
<!ENTITY % support-frage "support-frage" >
<!-- ================================================= -->
<!-- DOMAINS ATTRIBUTE OVERRIDE -->
<!-- ================================================= -->
<!ENTITY included-domains "" >
<!-- ================================================= -->
<!-- ELEMENT DECLARATIONS -->
<!-- ================================================= -->
<!ELEMENT support ((%support-frage;), (%titlealts;)?, (%support-kurze-antwort;), (%prolog;)?, (%support-lange-antwort;)?, (%related-links;)?, (%concept-info-types;)*) >
<!ATTLIST support id ID #REQUIRED conref CDATA #IMPLIED %select-atts; %localization-atts; %arch-atts; outputclass CDATA #IMPLIED domains CDATA "&included-domains;">
<!ELEMENT support-frage (%title.cnt;)* >
<!ATTLIST support-frage %id-atts; %localization-atts; base CDATA #IMPLIED %base-attribute-extensions; outputclass CDATA #IMPLIED>
<!ELEMENT support-kurze-antwort (%title.cnt;)*>
<!ATTLIST support-kurze-antwort %univ-atts; outputclass CDATA #IMPLIED>
<!ELEMENT support-lange-antwort ((%body.cnt;)*, (%section;|%example;)* )>
<!ATTLIST support-lange-antwort %id-atts; %localization-atts; base CDATA #IMPLIED %base-attribute-extensions; outputclass CDATA #IMPLIED>
<!-- ================================================= -->
<!-- SPECIALIZATION ATTRIBUTE DECLARATIONS -->
<!-- ================================================= -->
<!ATTLIST support %global-atts;class CDATA "- topic/topic concept/concept support/support">
<!ATTLIST support-kurze-antwort %global-atts; class CDATA "- topic/shortdesc support/support-kurze-antwort">
<!ATTLIST support-lange-antwort %global-atts; class CDATA "- topic/body concept/conbody support/support-lange-antwort">
<!ATTLIST support-frage %global-atts; class CDATA "- topic/title support/support-frage">
<!-- ================== End Support ================== -->

Nachdem die support-mod-Datei fertiggestellt ist, können Sie mit der Mantel-DTD support.dtd Topics vom Typ „Support“ erstellen.

XSLT-Stylesheets anpassen

Die Anpassung der XSLT-Stylesheets erfolgt in ähnlicher Weise wie die Anpassung der DTDs oder Moduldateien. Es werden aus bestehenden XSLT-Stylesheets die Anweisungen übernommen, die für die Verarbeitung der übergeordneten Elemente zuständig sind und gemäß den eigenen Wünschen modifiziert. Häufig besteht die Schwierigkeit darin, sowohl die passenden XSLT-Style-sheets als auch in den XSLT-Stylesheets die entsprechenden Anweisungen, das heißt die XSLT-Templates zu finden. Als Ausgangspunkt der Suche nach den Anweisungen zur Verarbeitung der Elemente dient das class-Attribut der Elemente. Wenn Sie zu einem class-Attribut keine Anweisungen beziehungsweise kein XSLT-Template in den XSLT-Stylesheets finden können, so suchen Sie nach dem class-Attribut der übergeordneten Elemente.

Im folgenden Beispiel wird gezeigt, wie die XSLT-Stylesheets für die Produktion von XHTML-Dateien verändert werden müssen, damit die XSLT-Stylesheets die spezialisierten Elemente <support>, <support-frage>, <support-kurze-antwort> und <support-lange-antwort> aus dem letzten Abschnitt verarbeiten können.

Im xsl-Verzeichnis des DITA Open Toolkits liegen die XSLT-Stylesheets, die die Produktion der einzelnen Ausgabemedien steuern. Für die Produktion von XHTML-Dateien ist die dita2xhtml.xsl-Datei zuständig.

In einem neu erstellten XSLT-Stylesheet, in welchem die XSLT-Templates zur Verarbeitung der spezialisierten Elemente definiert werden, wird die dita2xhtml.xsl-Datei importiert. Damit wird die bestehende Verarbeitung durch neue Verarbeitungsregeln ergänzt.

Im Einzelnen sind folgende Schritte notwendig, um ein XSLT-Stylesheet für die Verarbeitung von spezialisierten Elementen erstellen zu können:

Erstellen Sie ein XSLT-Stylesheet, das die dita2xhtml.xsl-Datei importiert.
Kopieren Sie die XSLT-Templates für die Verarbeitung der übergeordneten Elemente in das neue XSLT-Stylesheet.
Modifizieren Sie die XSLT-Templates, damit die gewünschte Ausgabe für die spezialisierten Elemente erzeugt wird.
Erzeugen Sie ein CSS, mit dem die transformierten Elemente in XHTML formatiert werden können.

Im folgenden Beispiel werden die XSLT-Stylesheets so modifiziert, dass bei der Ausgabe des Inhalts des <support-frage>-Elements der Text „Frage:“ vorangestellt wird. Bei der Ausgabe des Inhalts des <support-kurze-antwort>-Elements soll der Text „Antwort:“ ausgegeben werden.

Gehen Sie bei der Erstellung des XSLT-Stylesheets wie folgt vor:

Erstellen Sie das folgende leere XSLT-Stylesheet mit dem Namen support2xhtml.xsl.

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE xsl:stylesheet [
<!ENTITY gt "&gt;">
<!ENTITY lt "&lt;">
<!ENTITY rbl " ">
<!ENTITY nbsp "&#xA0;">
<!ENTITY quot "&#34;">
<!ENTITY copyr "&#169;">
]>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:param name="toolkitDir" select="'file:///c:/ditaot14/'"/>
    <xsl:import href="{$toolkitDir}xsl/dita2xhtml.xsl"/>
</xsl:stylesheet>

In der Deklaration des XSLT-Stylesheets ist der Pfad zum Installations-verzeichnis des DITA Open Toolkits angegeben, hier c:/ditaot14.

Speichern Sie das XSLT-Stylesheet in einem Verzeichnis außerhalb des Installationverzeichnisses des DITA Open Toolkits ab.
Erstellen Sie in der support2xhtml.xsl-Datei je ein XSLT-Template für die spezialisierten Elemente:

<xsl:template match="*[contains(@class, ' support/support ')]"></xsl:template>

<xsl:template match="*[contains(@class, ' support/support-frage ')]" ></xsl:template>

<xsl:template match="*[contains(@class, ' support/support-lange-antwort ')]"></xsl:template>

<xsl:template match="*[contains(@class, ' support/support-kurze-antwort ')]"></xsl:template>

Im match-Attribut wird angegeben, dass nach dem class-Attribut gesucht werden soll, dessen Werte die Kombination Topictypname/Elementname für die spezialisierten Elemente aufweist. Achten Sie auf die Leerzeichen im match-Attribut.

Finden Sie in der Datei c:/ditaot14/xsl/xslhtm/dita2htmlImpl.xsl das XSLT-Template mit dem folgenden match-Attribut *[contains(@class, ' topic/topic ')]/*[contains(@class, ' topic/title ')]. In diesem XSLT-Template wird das <title>-Element verarbeitet. Das <title>-Element wurde zum <support-frage>-Element spezialisiert, sodass dieses XSLT-Template angepasst werden muss, wenn der Text „Frage:“ vor dem Inhalt des <support-frage>-Elements ausgegeben werden soll.
Kopieren Sie den Inhalt des XSLT-Templates in die support2xhtml.xsl-Datei in das XSLT-Template, welches das <support-frage>-Element verarbeitet.
Ändern Sie das match-Attribut von *[contains(@class, ' topic/topic ')]/*[contains(@class, ' topic/title ')] auf *[contains(@class, ' support/support-frage ')]. Dann sieht die support2html.xsl-Datei wie folgt aus:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE xsl:stylesheet [
<!ENTITY gt "&gt;">
<!ENTITY lt "&lt;">
<!ENTITY rbl " ">
<!ENTITY nbsp "&#xA0;">
<!ENTITY quot "&#34;">
<!ENTITY copyr "&#169;2>
]>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:param name="toolkitDir" select="'file:///c:/ditaot14/'"/>
    <xsl:import href="{$toolkitDir}xsl/dita2xhtml.xsl"/>
    <xsl:template match="*[contains(@class, ' support/support ')]"></xsl:template>
    <xsl:template match="*[contains(@class, ' support/support-frage ')]">
        <xsl:param name="headinglevel">
            <xsl:choose>
                <xsl:when test="count(ancestor::*[contains(@class,' topic/topic ')])&gt; 6">6</xsl:when>
                <xsl:otherwise>
                    <xsl:value-of select="count(ancestor::*[contains(@class,' topic/topic ‚)])"/>
                </xsl:otherwise>
            </xsl:choose>
        </xsl:param>
        <xsl:element name="h{$headinglevel}">
            <xsl:attribute name="class">topictitle <xsl:value-of select="$headinglevel"/></xsl:attribute>
            <xsl:call-template name="commonattributes"/>
            <xsl:apply-templates/>
        </xsl:element>
        <xsl:value-of select="$newline"/>
    </xsl:template>
    <xsl:template match="*[contains(@class, ' support/support-lange-antwort ')]"></xsl:template>
    <xsl:template match="*[contains(@class, ' support/support-kurze-antwort ')]"></xsl:template>

Definieren Sie den HTML-Code, der die Ausgabe des Textes „Frage:“ erzeugt.

Der HTML-Code könnte wie folgt aussehen:

<div class="support-frage">
    <span class="support-frage-txt">Frage: </span>
</div>

Integrieren Sie in den HTML-Code in das XSLT-Template zur Verarbeitung des <support-frage>-Elements wie folgt:

<xsl:template match="*[contains(@class, ' support/support-frage ')]">
    <xsl:param name="headinglevel">
        <xsl:choose>
            <xsl:when test="count(ancestor::*[contains(@class,' topic/topic ')])&gt; 6">6</xsl:when>
            <xsl:otherwise>
                <xsl:value-of select="count(ancestor::*[contains(@class,' topic/topic ‚)])"/>
            </xsl:otherwise>
        </xsl:choose>
    </xsl:param>
    <xsl:element name="h{$headinglevel}">
        <xsl:attribute name="class">topictitle <xsl:value-of select="$headinglevel"/></xsl:attribute>
        <xsl:call-template name="commonattributes"/>
        <div class="support-frage">
            <span class="support-frage-txt">Frage:</span>
            <xsl:apply-templates/>
        </div>
    </xsl:element>
    <xsl:value-of select="$newline"/>
</xsl:template>

Damit ist die Definition des XSLT-Templates zur Verarbeitung des <support-frage>-Elements abgeschlossen.

Als Nächstes wird das XSLT-Template zur Verarbeitung des <support-kurze-antwort>-Elements definiert. Das <support-kurze-antwort>-Element wurde aus dem <shortdesc>-Element spezialisiert und im Inhaltsmodell als erforderliches Element definiert. Im ursprünglichen Inhaltsmodell ist das <shortdesc>-Element optional und kann durch das optionale <abstract>-Element ersetzt werden. Da das <support-kurze-antwort>-Element als erforderlich definiert wurde, ist es nicht notwendig, das bestehende XSLT-Template zur Verarbeitung des optionalen <shortdesc>-Elements und des <abstract>-Elements zu verwenden. Daher wird im Folgenden ein neues XSLT-Template definiert, dass den HTML-Code zur Ausgabe des Textes „Antwort:“ produziert.

Definieren Sie den HTML-Code, der die Ausgabe des Textes „Antwort:“ erzeugt.

Der HTML-Code könnte wie folgt aussehen:

<div class="support-kurze-antwort">
    <span class="support-kurze-antwort-txt">Antwort: </span>
</div>

Integrieren Sie in den HTML-Code in das XSLT-Template zur Verarbeitung des <support-kurze-antwort>-Elements wie folgt:

<xsl:template match="*[contains(@class, ' support/support-kurze-antwort ')]" mode="outofline">
    <div class="support-kurze-antwort">
        <span class="support-kurze-frage-txt">Antwort </span>
        <xsl:apply-templates/>
    </div>
</xsl:template>

Damit ist die Definition des XSLT-Templates zur Verarbeitung des <support-kurze-frage>-Elements abgeschlossen.

Für das <support-lange-antwort>-Element, das vom <conbody>-Element spezialisiert wurde, führt die Suche nach dem match-Attribut mit dem Inhalt concept/conbody zu keinem Ergebnis, da für das <conbody>-Element keine eigene Formatierung definiert ist. Daher ist eine Suche nach der übergeordneten Informationsstruktur notwendig, das heißt, es muss nach topic/body gesucht werden.

Kopieren Sie den Inhalt des XSLT-Templates mit dem match-Attribut *[contains(@class,‘ topic/body ‚)] in das XSLT-Template, welches das <support-lange-antwort>-Element verarbeitet.

<xsl:template match="*[contains(@class,' support/supportlange-antwort ')]" name="topic.body">
    <xsl:variable name="flagrules">
        <xsl:call-template name="getrules"/>
    </xsl:variable>
    <xsl:variable name="conflictexist">
        <xsl:call-template name="conflict-check">
            <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
    </xsl:variable>
    <div>
        <xsl:call-template name="commonattributes"/>
        <xsl:call-template name="setidaname"/>
        <xsl:call-template name="gen-style">
            <xsl:with-param name="conflictexist" select="$conflictexist"></xsl:with-param>
            <xsl:with-param name="flagrules" select="$flagrules"></xsl:with-param>
        </xsl:call-template>
        <xsl:call-template name="start-flagit">
            <xsl:with-param name="flagrules" select="$flagrules"></xsl:with-param>
        </xsl:call-template>
        <xsl:call-template name="start-revflag">
            <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:apply-templates select="precedingsibling::*[contains(@class,' topic/abstract ')]" mode="outofline"/>
        <xsl:apply-templates select="precedingsibling::*[contains(@class,' topic/shortdesc ')]" mode="outofline"/>
        <xsl:apply-templates select="followingsibling::*[contains(@class,' topic/related-links ')]" mode="prereqs"/>
        <xsl:apply-templates/>
        <xsl:call-template name="end-revflag">
            <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="end-flagit">
            <xsl:with-param name="flagrules" select="$flagrules">
            </xsl:with-param>
        </xsl:call-template>
    </div>
    <xsl:value-of select="$newline"/>
</xsl:template>

Da das <abstract>-Element aus dem Inhaltsmodell entfernt wurde, können aus dem XSLT-Template alle Anweisungen entfernt werden, die das <abstract>-Element betreffen.

Der Inhalt des <support-lange-antwort>-Elements soll in einem <div>-Block mit der Klasse support-lange-antwort ausgegeben werden. Dazu wird die entsprechende <xsl:apply-templates>-Anweisung eingefügt.

Somit sieht das XSLT-Template für die Verarbeitung des <support-lange-antwort>-Elements wie folgt aus:

<xsl:template match="*[contains(@class,' support/supportlange-antwort ')]" name="topic.body">
    <xsl:variable name="flagrules">
        <xsl:call-template name="getrules"/>
    </xsl:variable>
    <xsl:variable name="conflictexist">
        <xsl:call-template name="conflict-check">
            <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
    </xsl:variable>
    <div>
        <xsl:call-template name="commonattributes"/>
        <xsl:call-template name="setidaname"/>
        <xsl:call-template name="gen-style">
            <xsl:with-param name="conflictexist" select="$conflictexist"></xsl:with-param>
            <xsl:with-param name="flagrules" select="$flagrules"></xsl:with-param>
        </xsl:call-template>
        <xsl:call-template name="start-flagit">
            <xsl:with-param name="flagrules" select="$flagrules"></xsl:with-param>
        </xsl:call-template>
        <xsl:call-template name="start-revflag">
            <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:apply-templates select="precedingsibling::*[contains(@class,' topic/shortdesc ')]" mode="outofline"/>
        <div class="support-lange-antwort">
            <xsl:apply-templates/>
        </div>
        <xsl:call-template name="end-revflag">
            <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="end-flagit">
            <xsl:with-param name="flagrules" select="$flagrules"></xsl:with-param>
        </xsl:call-template>
    </div>
    <xsl:value-of select="$newline"/>
</xsl:template>

Damit ist die Definition des XSLT-Templates zur Verarbeitung des <support-kurze-frage>-Elements abgeschlossen.

Beim <support>-Element muss nur dafür gesorgt werden, dass es verarbeitet wird.

Fügen Sie in das XSLT-Template für die Verarbeitung des <support>-Elements die Anweisung <xsl:apply-imports/> hinzu.

<xsl:template match="*[contains(@class, ' support/support ')]">
    <xsl:apply-imports/>
</xsl:template>

Dadurch werden alle XSLT-Templates verwendet, die für das <support>-Element anwendbar sind.

Damit sieht die vollständige support2html.xsl-Datei zur Verarbeitung der Elemente <support>, <support-frage>, <support-kurze-antwort> und <support-lange-antwort> wie folgt aus:

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE xsl:stylesheet [
<!ENTITY gt "&gt;">
<!ENTITY lt "&lt;">
<!ENTITY rbl " ">
<!ENTITY nbsp "&#xA0;">
<!ENTITY quot "&#34;">
<!ENTITY copyr "&#169;2>
]>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:param name="toolkitDir" select="'file:///c:/ditaot14/'"/>
  <xsl:import href="{$toolkitDir}xsl/dita2xhtml.xsl"/>
<xsl:template match="*[contains(@class, ' support/support ')]">
  <xsl:apply-imports/>
</xsl:template>
<xsl:template match="*[contains(@class, ' support/support-frage ')]">
  <xsl:param name="headinglevel">
    <xsl:choose>
      <xsl:when test="count(ancestor::*[contains(@class,' topic/topic ')])&gt; 6">6</xsl:when>
      <xsl:otherwise>
          <xsl:value-of select="count(ancestor::*[contains(@class,' topic/topic ‚)])"/>
      </xsl:otherwise'>
    </xsl:choose>
  </xsl:param>
  <xsl:element name="h{$headinglevel}">
    <xsl:attribute name="class">topictitle <xsl:value-of select="$headinglevel"/></xsl:attribute>
    <xsl:call-template name="commonattributes"/>
    <div class="support-frage">
      <span class="support-frage-txt">Frage: </span>
      <xsl:apply-templates/>
    </div>
  </xsl:element>
  <xsl:value-of select="$newline"/>
</xsl:template>
<xsl:template match="*[contains(@class,' support/supportlange-antwort ')]" name="topic.body">
    <xsl:variable name="flagrules">
        <xsl:call-template name="getrules"/>
    </xsl:variable>
    <xsl:variable name="conflictexist">
        <xsl:call-template name="conflict-check">
            <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
    </xsl:variable>
    <div>
        <xsl:call-template name="commonattributes"/>
        <xsl:call-template name="setidaname"/>
        <xsl:call-template name="gen-style">
            <xsl:with-param name="conflictexist" select="$conflictexist"></xsl:with-param>
            <xsl:with-param name="flagrules" select="$flagrules"></xsl:with-param>
        </xsl:call-template>
        <xsl:call-template name="start-flagit">
            <xsl:with-param name="flagrules" select="$flagrules"></xsl:with-param>
        </xsl:call-template>
        <xsl:call-template name="start-revflag">
            <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:apply-templates select="precedingsibling::*[contains(@class,' topic/shortdesc ')]" mode="outofline"/>
        <div class="support-lange-antwort">
            <xsl:apply-templates/>
        </div>
        <xsl:call-template name="end-revflag">
            <xsl:with-param name="flagrules" select="$flagrules"/>
        </xsl:call-template>
        <xsl:call-template name="end-flagit">
            <xsl:with-param name="flagrules" select="$flagrules"></xsl:with-param>
        </xsl:call-template>
    </div>
    <xsl:value-of select="$newline"/>
</xsl:template>
<xsl:template match="*[contains(@class, ' support/support-kurze-antwort ')]" mode="outofline">
    <div class="support-kurze-antwort">
        <span class="support-kurze-frage-txt">Antwort </span>
        <xsl:apply-templates/>
    </div>
</xsl:template>

Damit ist das XSLT-Stylesheet zur Verarbeitung der spezialisierten Elemente fertiggestellt.

Als letzter Schritt ist noch ein CSS zu definieren, welches die bei der XSLT-Transformation in den XHTML-Dateien erzeugten Klassen support-frage, support-frage-txt, support-kurze-antwort und support-kurze-antwort-txt formatieren kann.

Erstellen Sie ein CSS wie das folgende:

@import "commonltr.css";
*[class = 'support-kurze-aantwort-txt'] {
font-family: Arial;
font-size: 16pt;
font-weight: bold;
}
*[class = 'support-kurze-aantwort'] {
margin-left: 5px;
}
*[class = 'support-lange-antwort-txt'] {
font-family: Arial;
font-size: 16pt;
font-weight: bold;
}
*[class = 'support-lange-aantwort'] {
margin-left: 5px;
}

Speichern Sie das CSS in dem Verzeichnis ab, in dem sich die commonltr.css Datei und die transformierte XML-Datei befinden.

Um das XSLT-Stylesheets zu testen, erstellen Sie zunächst eine XML-Datei aus dem Topictyp „Support“. Transformieren Sie danach die XML-Datei mit ant -f support2html.xsl zu einer XHTML-Datei. Überprüfen Sie die XHTML-Datei im Browser.

<< zurück

vor >>