XMLidP2000

Sitemap

Sitemap

1 Einführung
1.1 Warum mehr weniger ist
1.2 Warum mehr mehr ist
1.3 Wohin die Reise geht
2 Was sind Dokumente?
2.1 Eine kurze Geschichte der Textverarbeitung
2.2 Bestandteile eines Dokumentes
2.3 Die neue, alte Idee: Strukturorientiert schreiben
2.4 Die Entwicklung des Hypertextes
2.5 Textformate im Web
2.6 Das SGML-Konzept: Generic Markup
2.7 Dokumente versus Daten
3 XML im Web
3.1 XML bei der Verwaltung von Websites
3.2 Clientseitige XML-Interpretation
3.2.1 XML mit CSS
3.2.2 XML mit XSL(T)
3.3 XML auf dem Server
3.4 Linking-Möglichkeiten von XML
3.5 XML als Datenaustauschformat
4 XML Quick Start
4.1 Dokumenttyp-Definition (DTD) und Instanzen
4.2 Verarbeitung der Dokumente
4.2.1 Beispiel: Verarbeitung mit Cost/TCL
4.2.2 Beispiel: Verarbeitung mit XSLT
4.2.3 Beispiel: XML/XSLT im Internet Explorer
4.2.4 Fazit
5 XML-DTDs: Die verständliche Beschreibung
5.1 Ein Wort zur Notation
5.2 Dokumente
5.3 Elemente
5.4 Zeichen, Namen und Zeichendaten
5.5 Kommentare
5.6 Processing Instructions
5.7 Wo bleibt Multimedia?
5.8 Dokumenttyp-Definition (DTD)
5.8.1 Elementtyp-Deklaration
5.8.2 Attributlisten-Deklaration
5.8.3 Möglichkeiten, die DTD zu gestalten und zu gliedern
5.8.4 Notation-Deklaration
6 Namensräume in XML
7 XPath: Adressierung von XML-Dokumentteilen
7.1 Zu Grunde liegendes Datenmodell
7.2 Zugriff auf den Datenbaum
7.3 Hilfe von Operatoren
7.4 Kernfunktionen für den Datenzugriff
8 XML: Linking
8.1 Notwendige Begriffe
8.2 XLink: einfache und erweiterte Links
8.2.1 Einfache Verweise
8.2.2 Erweiterte Links
8.2.3 XLink in der Praxis
8.3 XPointer: Verweise in Dokumente hinein
8.3.1 XPath-Erweiterungen in XPointer
9 Überblick über Stylesheet-Sprachen
9.1 Cascading Style Sheets
9.1.1 Wertzuweisungen
9.1.2 Formatierungsmodell
9.1.3 CSS und XML
9.1.4 Ein Beispiel: XML im Mozilla
9.2 Document Style Semantics and Specification Language
9.2.1 Flow Objects
9.2.2 Verarbeitungs-Modus
9.2.3 DSSSL praktisch
9.2.4 Langer Marsch von DSSSL nach HTML
9.3 Extensible Stylesheet Language (XSLT und XSL)
9.3.1 Verhältnis von XSLT zu XSL
9.3.2 Formatierung mit XSL
10 XSL-Transformationen
10.1 Grundsätzliches über Templates
10.2 Ergänzungen zum Datenmodell von XPath
10.3 Struktur von XSLT-Stylesheets
10.4 Den Ergebnisbaum erzeugen
10.4.1 Diverse Basiselemente
10.4.2 Formatierte Nummerierung
10.4.3 Schleifen und bedingte Verarbeitung
10.4.4 Sortieren
10.4.5 Variable und Parameter
10.4.6 Zusätzliche Funktionen
10.4.7 XSLT-Erweiterungen
10.4.8 message, output
11 XSLT in Web-Anwendungen
11.1 XSLT im Internet Explorer
11.2 Linklisten erzeugen
11.3 Details einer Literaturgeschichte
11.3.1 Sortierte Überblicksseiten
11.3.2 Kalender: einzelne Tage ausgeben
12 XML-Editoren
12.1 Übersicht
12.1.1 Emacs + PSGML (mit XML-Unterstützung)
12.1.2 XML Notepad
12.1.3 XML Spy
12.1.4 XMetal
12.1.5 Epic
12.1.6 MarkupKit (für MS Word)
12.1.7 WordPerfect Office2000
12.2 Emacs und PSGML (mit XML-Unterstützung)
12.3 XML-Notepad
12.4 XML Spy
12.5 XMetal
12.6 Epic
12.7 MarkupKit (für MS Word)
12.8 WordPerfect Office2000
12.9 Fazit
13 Entwicklung einer DTD
13.1 Auswahl einer Mehrzweck-DTD
13.2 Entwurf einer DTD
13.2.1 Dokumentanalyse
13.2.2 Tipps und Tricks
13.3 Instanzen ohne DTD
14 Herstellung dieses Buches
14.1 Zielsetzung und Randbedingungen
14.2 Definition der DTD
14.2.1 Schritt 1: Die Grobstruktur
14.2.2 Schritt 2: Elemente auf Zeichenebene
14.2.3 Schritt 3: Die Details
14.3 Formatieren des Manuskriptes
14.3.1 Konvertierung in HTML
14.3.2 Aufbereitung für den Ausdruck
14.4 Erfahrungen mit der zweiten Auflage
15 Anwendungsbeispiel Literatur
15.1 Vorüberlegungen
15.2 En détail: die Autoren in der DTD
15.3 Wie die Daten ins Web gelangen
15.3.1 Inhaltsverzeichnis generieren
15.3.2 Ausgabe der Autorendaten
15.4 Vollständige Listings
15.4.1 DTD für die Literaturgeschichte
15.4.2 DSSSL-Listing: Inhaltsverzeichnis
15.4.3 DSSSL-Listing: Ausgabe eines einzelnen Autors
15.4.4 Perl-Code für Ausgabe einzelner Autoren
16 Verteilte Softwareverwaltung mit XML
16.1 Aufgabenbeschreibung
16.2 XML als Datenbasis
16.3 Bilden von DTD-Hierarchien
16.4 Zusammentragen von verteilten XML-Fragmenten
16.5 Fazit
16.6 Stylesheet zur Transformation in HTML
17 E-Commerce mit XML
17.1 B2B-E-Commerce
17.1.1 Die Rolle von XML
17.1.2 Technische Aspekte
17.2 BMEcat
17.3 Electronic Business XML (ebXML)
17.3.1 Arbeitsgruppen
17.3.2 Zeitplan des Projekts
17.4 XML und EDIFACT
18 XML und Apache
18.1 XML-Transformation per CGI
18.1.1 Konfiguration des Servers
18.1.2 CGI-Skript: xmlhandler.cgi
18.1.3 Beispiel: von HTML nach HTML mit DSSSL oder XSLT
18.2 Cocoon
18.2.1 Extensible Server Pages (XSP)
18.2.2 Beispiel: Formatierung in PDF mit XSL
18.2.3 Beispiel: Simuliertes XLink mit Dynamic HTML/JavaScript
18.2.4 Installation
19 XHTML: Neues HTML 4 — erweiterbar
19.1 Status quo: HTML neu definiert
19.2 Modulare Zukunft
20 Transformation von XML in WML und HTML
20.1 Erzeugen der WML-Dateien
20.2 Erzeugen der HTML-Dateien
21 Ausblick
21.1 XML Schema
21.2 Programmierung mit XML-Daten
21.3 XML und Java
21.4 Resource Description Framework
21.5 Die Zukunft
A Extensible Markup Language (XML) 1.0
A.1 Einleitung
A.1.1 Herkunft und Ziele
A.1.2 Terminologie
A.2 Dokumente
A.2.1 Wohlgeformte XML-Dokumente
A.2.2 Zeichen
A.2.3 Allgemeine syntaktische Konstrukte
A.2.4 Zeichendaten und Markup
A.2.5 Kommentare
A.2.6 Processing Instructions
A.2.7 CDATA-Abschnitte
A.2.8 Prolog und Dokumenttyp-Deklaration
A.2.9 Standalone-Dokumentdeklaration
A.2.10 Behandlung von Leerraum
A.2.11 Behandlung des Zeilenendes
A.2.12 Identifikation der Sprache
A.3 Logische Strukturen
A.3.1 Start-Tags, End-Tags und Leeres-Element-Tags
A.3.2 Elementtyp-Deklarationen
A.3.3 Attributlisten-Deklaration
A.3.4 Bedingte Abschnitte
A.4 Physikalische Strukturen
A.4.1 Zeichen- und Entity-Referenzen
A.4.2 Entity-Deklarationen
A.4.3 Analysierte Entities
A.4.4 Behandlung von Entities und Referenzen durch einen XML-Prozessor
A.4.5 Konstruktion des Ersetzungstextes von internen Entities
A.4.6 Vordefinierte Entities
A.4.7 Notation-Deklarationen
A.4.8 Dokument-Entity
A.5 Konformität
A.5.1 Validierende und nicht-validierende Prozessoren
A.5.2 Benutzen von XML-Prozessoren
A.6 Notation
A.7 Anhang A: Referenzen
A.7.1 Normative Referenzen
A.7.2 Weitere Referenzen
A.8 Anhang B: Zeichenklassen
A.9 Anhang C: XML und SGML (nicht normativ)
A.10 Anhang D: Expansion von Entity- und Zeichenreferenzen (nicht normativ)
A.11 Anhang E: Deterministische Inhaltsmodelle (nicht normativ)
A.12 Anhang F: Automatische Erkennung von Zeichenkodierungen (nicht normativ)
A.13 Anhang G: XML-Arbeitsgruppe des W3C (nicht normativ)
B Verknüpfen von Style Sheets mit XML-Dokumenten Version 1.0
B.1 Die xml-stylesheet-Processing-Instruction
B.2 Anhang A: Referenzen
B.3 Anhang B: Begründung
C Verhältnis von XML zu SGML und HTML
C.1 XML und SGML
C.2 XML und HTML
D Übersichten
D.1 Cascading Style Sheets
D.1.1 CSS-Eigenschaften und -Werte
D.1.2 CSS-Muster
D.2 DSSSL: Flow Objects
D.3 Syntax der XSLT-Elemente
D.4 DTD-Fragment für XSLT-Stylesheets (nicht normativ)
D.5 Relevante Spezifikationen und Organisationen
D.5.1 International Organization for Standardization
D.5.2 World Wide Web Consortium
D.5.3 Organization for the Advancement of Structured Information Standards
D.5.4 Internet Society und Internet Engineering Task Force
D.5.5 ISO-639-Sprachcodes
D.5.6 ISO-3166-Ländercodes
D.5.7 Zeichensatz ISO-Latin-1
D.5.8 Sonderzeichen
D.6 XML-1.0-Regeln

15.3.1 Inhaltsverzeichnis generieren

Per DSSSL eine HTML-Datei zu generieren bedeutet eigentlich, etwas zu tun, das DSSSL in der Jade-Implementierung gar nicht kann. Denn das wäre Aufgabe der Transformation Language (die Jade nicht beherrscht). James Clark hat als Alternative eigene Flow Objects für den SGML-Output kreiert. Näheres dazu ist Kapitel 9 zu entnehmen, denn für das Buchmanuskript respektive seinen Output waren diese Objekte natürlich ebenfalls Voraussetzung. Im Folgenden sind jeweils nur die gerade bedeutsamen Teile des Stylesheets abgedruckt; am Ende des Kapitels ist es vollständig nachzulesen.

Nach den Präliminarien geht es an die Default-Regel. Sie ist dann anzuwenden, wenn keine spezielle Anweisung für ein Element vorgegeben ist.

(default (empty-sosofo))

In diesem Fall heißt die Vorgabe: Tue nichts. Dafür steht die leere Spezifikation einer Sequenz von Flow Objects (Specification of a Sequence of Flow Objects, SOSOFO). Solche Vorgaben dienen dazu, sich die unnötigen Anweisungen für einzelne Elemente zu sparen. Den eigentlichen Anfang macht das Element lithist, das Top-Level-Element des Dokuments. In ihm ist festgelegt, dass es sich um ein HTML-Dokument nach der W3C-Vorgabe handelt, und es generiert ein Top-Level-Element html, in das alle weiteren eingebettet sind.

(element lithist
  (make sequence
    (make document-type 
          name: "HTML" 
          public-id: "-//W3C//DTD HTML 4.0//EN")
    (make element gi: "HTML"
       (make sequence
          (make element gi: "HEAD"
; ----- hier werden HEAD, META und LINK generiert
	    (make sequence
         	(make element gi: "TITLE"  
                          (literal "Dichter und Schriftsteller"))   
        	   (make empty-element gi: "LINK"
           		 attributes: (cons (list "REL" "STYLESHEET")
                            (cons (list "TYPE" "text/css")
                               (cons (list "HREF" "/style/litanw.css")
                                   (cons (list "TITLE" "Literatur")
                        '())))))
         	   (make empty-element  gi: "META"
            		attributes: (cons (list "name" "generator" )
                              (cons (list "content" "from XML source 
                                and Style Sheet via James Clark's Jade")
                                (cons (list "name" "author")
                                   (cons (list "content" "Henning Behme")
                              '())))))))
          (make element gi: "BODY"
; --- Überschriften und Bearbeitung weiterer Elemente
          )
))))

Das zweimalige make sequence sorgt dafür, dass der Dokumenttyp und das Top-Level-Element sowie die danach vorkommenden Elemente für sich ebenfalls eine Folge bilden (innerhalb von html). Dabei handelt es sich um zwei weitere: head und body.

          (make element gi: "BODY"
            (make sequence
		(make element gi: "H1" 
			attributes: (cons (list "class" "de") '())
				(literal "Dichter und Schriftsteller"))
		(make element gi: "H1"
			attributes: (cons (list "class" "en") '())
				(literal "Poets and Writers"))
          ))
; --- weitere Angaben zum Body

Der resultierende HTML-Code sieht folgendermaßen aus:

<BODY>
  <H3 class="de">Dichter und Schriftsteller</H3>
  <H3 class="en">Poets and Writers</H3>

Im body kommt ebenfalls make sequence als erstes vor, weil alles, was hier seinen Platz haben soll, an dieser Stelle nacheinander abgearbeitet wird. Gäbe es in der XML-Instanz der Literaturgeschichte Elemente wie die oben generierten H1-Überschriften, wären sie ebenfalls leicht zu extrahieren. Allerdings müsste man für den head diese Überschrift mit Hilfe eines besonderen Modus ausgeben, wenn man aus dem Überschriftenelement auch einen Titel erzeugen will.

Modi, dies zur Erinnerung, dienen dazu, Elemente einer Sonderbehandlung zu unterziehen. Dies insbesondere dann, wenn Elemente mehr als einmal in der Ausgabe vorkommen sollen. Ein Inhaltsverzeichnis ist das beliebteste Beispiel: Dort müssen Kapitelüberschriften schon einmal auftauchen, abgesehen von ihrem angestammten Platz.

Vorsicht!

Irritierend mag auf den ersten Blick sein, dass dieses Style Sheet (DSSSL) über das link-Element ein ganz anderes (CSS) voraussetzt und referenziert. Grund dafür ist, dass die Ausgabe auch in HTML formatiert sein sollte, um beispielsweise Überschriften in unterschiedliche Farben anzuzeigen (je nach Sprache). Statt der veralteten HTML-Elemente font etc. (das W3C rät von ihnen ab) kommt hier ein Cascading Style Sheet zum Einsatz, das Vorgaben für die einzelnen Elemente macht. Es hier ebenfalls abzudrucken führte zu weit, weil es vom eigentlichen Thema ablenkteFussnoteOnline ist auch das Cascading Style Sheet einsehbar.. Auf jeden Fall macht die Arbeit mit CSS auch DSSSL-Style-Sheets komplexer, wenn die CSS-Anweisungen ins HTML-Dokument geschrieben werden müssen. Mit font et cetera wäre das allerdings nicht besser.

Innerhalb des body, im Style Sheet innerhalb des Elements lithist, stehen bis auf wenige Details alle wichtigen Vorgaben für das HTML-Dokument. Abgesehen von einigen Überschriften (h1 und h3 mit den Style-Sheet-Klassen de und en) ist ein Formular (siehe unten stehendes Listing) Hauptbestandteil des body, das dazu auffordert, aus einer Liste eine Autorin beziehungsweise einen Autor auszusuchen und auf okay zu klicken:

(make element gi: "FORM"
     attributes: (cons (list "METHOD" "POST")
                   (cons (list "ACTION" "/cgi-bin/xml/xmla")
                 '()))
                  (make element gi: "SELECT"
                       attributes: (cons (list "NAME" "AUTHOR")
                                      (cons (list "SIZE" "15")
                                '())) (process-children))
                  (make element gi: "INPUT" 
                        attributes: (cons (list "TYPE" "SUBMIT")
                                    (cons (list "VALUE" "okay")
                                 '())) (empty-sosofo)))

Bei diesem Formular ist strukturiertes Denken im Sinne des Flow-Object-Baums sinnvoll, weil sonst einzelne Elemente des Formulars im falschen Flow Object landen. Hier dreht es sich darum, dass im Element body bis auf eine Kleinigkeit des Formulars (das, was aus dem Element author ausgegeben werden soll —, hier nur der Name) bereits alles enthalten sein muss, auch der Nachsatz mit der Angabe der letzten Veränderung.

Das Element form erhält über attributes die Methode post und die Aktion /cgi-bin/xml/xmla zugewiesen. Außerdem beinhaltet das Formular ein select-Statement und einen submit-Button. Innerhalb von select steckt die Abarbeitung der Autoreneinträge (process-children), so dass dort (im Element author) nicht mehr viel zu geschehen hat ...

(element author
        (make element gi: "OPTION"
              attributes: (cons (list "VALUE" (attribute-string "ID"))
                      '()) (process-matching-children 'name)))
          

Jade generiert aus diesen Zeilen für jeden Autor einen Eintrag, der folgendermaßen aussieht:

<OPTION VALUE="AUE">Hartmann von Aue</OPTION>

Dabei extrahiert die Funktion attribute-string aus dem Attribut id die eindeutige Kennung des jeweiligen Autors, so dass im HTML-Dokument Strings landen, die wie oben für Hartmann von Aue stehen (AUE). Wie das Formular aussieht, zeigt die folgende Abbildung:

So einfach es geht: nur ein Formular
    mit select und vielen (hier nur teilweise sichtbaren)
    Optionen

Abbildung 56: So einfach es geht: nur ein Formular mit select und vielen (hier nur teilweise sichtbaren) Optionen

Was beim Klick auf den okay-Button passiert, regelt ein Skript (in diesem Fall Perl), das die vom Formular per post weitergegebene id des Autors auswertet und aus vorgegebenen Teilen eines zweiten Stylesheets eine Autorenseite generiert. Das Skript ist am Schluss dieses Kapitels abgedruckt und sollte niemandem, der schon einmal Perl ausprobiert hat, Kopfschmerzen bereiten.

Valid HTML 4.01!Valid CSS!