XML. extensible Markup Language. Dr. Beatrice Amrhein.

Transkript

1 XML extensible Markup Language Dr. Beatrice Amrhein

2 2

3 Inhaltsverzeichnis 1 XML Grundlagen Die wichtigsten Punkte XML Sprachen und Anwendungen Der Aufbau eines XML Dokuments Elemente Attribute Zeichen- und Entity-Referenzen Kommentare und Verarbeitungsanweisungen Die XML Deklaration XML Knotentypen und Nachfolger Wohlgeformtheit: Zusammenfassung Namespaces Wozu dienen Namespaces? Definition eines Namespaces Qualifizierte Element-Namen XSD: XML Schema Definition Deklarationen <--> Definitionen Deklaration von einfachen Typen Vordefinierte primitive Schema Typen Attribut Deklarationen Komplexe Schema Typen Spezielle Schema Elemente Schlüssel SAX: Simple Application Interface for XML Was ist SAX? Wofür ist SAX geeignet? Wie funktioniert SAX? Übersicht über das SAX API Implementation des Default Handlers Fehlerbehandlung: ErrorHandler...42 Ein SAX Beispiel DOM: Das Document Object Model...45 Was ist DOM?...45 Die DOM Node Typen Die org.w3c.dom Java Interfaces Benutzen des DOM Parsers StAX: Streaming API for XML Was ist StAX? JAXB: Java Architecture for XML Binding Die JAXB Architektur Das Binding Übersetzung verschiedener Basis-Datentypen Erzeugen der Java Klassen Einlesen der XML Daten Schreiben der Daten in ein XML File Anpassen der generierten Java Klassen und Member Variablen Externe Binding-Deklaration Erzeugen von Schematas Schreiben von XML Daten ohne ObjectFactory Die Transformations-Sprache XSLT

4 8.1 Wie funktioniert XSLT? Der Aufbau eines Stylesheets: Templates Die wichtigsten XSLT Befehle Grundlegendes zu XSLT Default Template Regeln Template Driven vs. Data Driven Stylesheets XPath: Die XSL Adressierungssprache Die XPath Syntax Adressierungs-Achsen Die wichtigsten XPath Funktionen XSL-FO Einführung Die wichtigsten FO Elemente Die wichtigsten Attribute

5 XSLT / XPath / XSL-FO Die Transformations- und Adressierungs-Sprachen für XML

6 Die XSL Sprachen Einleitung, Motivation XSL ist ein vom World Wide Web Consortium empfohlener Standard W3C Recommendation von XSLT2.0 und XPath2.0, sowie Xquery 1.0 vom 23 Januar 2007 XSLT: XPath: W3C Recommendation des XSL- Formatting Objects Teil vom Dezember 2006 XSL-FO: Vergleich: CSS und XSL Die W3C hat mit dem XSL Standard angefangen, bevor derjenige von CSS (Cascading Stylesheet Language) festgelegt war. Warum gibt es überhaupt zwei Stylesheet Sprachen? CSS XSL Verwendung mit HTML ja nein Verwendung mit XML ja ja Transformations-Sprache nein ja Syntax CSS XML CSS ist für das Layouting von HTML-Dokumenten geeignet. XSL ist angepasst an die Bedürfnisse von XML. XSL ist viel mächtiger, differenzierter und ausgefeilter als CSS. XSL kann XML- Dokumente beliebig transformieren (also auch in andere Sprachen wie TeX, Java, HTML/CSS,... umformen) Beide Sprachen können als Stylesheet für XML- Dokumente verwendet werden. CSS und XSL benutzen das gleiche Formatierungs-Modell und beide Sprachen bieten die gleichen Formatierungs-Möglichkeiten. CSS Stylesheet für HTML Files HTML benutzt vordefinierte (und darum allgemein bekannte) Tags: <h1> Titel-Element <p> neuer Abschnitt,... In CSS wird definiert, wie die verschiedenen HTML Elemente darzustellen sind (Fonts, Farben,...) h1 { font-family: sans-serif; Die h1 Header sollen mit einer sans-serif Schrift der Grösse 48 font-size: 48pt } ausgegeben werden. p { font-size: 8pt; color: blue } Alle <p> - Elemente sollen in einer 8pt Schrift in blauer Farbe ausgegeben werden. Die Browser kennen diese HTML Tags und verwenden ein CSS (Default-) Stylesheet für deren Darstellung. 66

7 XSL - Stylesheet für XML XML benutzt keine vordefinierten Tags: <table> kann eine HTML Tabelle oder auch ein Möbelstück sein. Im XML-Dokument steht nicht, wie die Daten dargestellt werden sollen. Es braucht einen Mechanismus, welcher beschreibt, wie die Daten eines XML-Dokumentes dargestellt werden sollen. XSL bietet diesen Mechanismus Das XML Dokument soll nur die reinen Daten enthalten und (im Gegensatz zu HTML) nichts über deren Darstellung (ob als Liste, Tabelle, oder als Fliesstext in Abschnitte unterteilt,...) aussagen. Mit Hilfe eines XSL Stylesheet wird festgelegt, wie diese Daten dargestellt werden sollen. CSS bietet keine Möglichkeit, Daten zu transformieren oder in Tabellen, Listen, usw. zu verpacken. XSL ist eine Sprache, welche XML nach (X)HTML (oder einer beliebigen Sprache) übersetzen kann, XML Daten sortieren oder filtern kann, Spezielle Teile von XML Dokumenten adressieren kann, XML Daten zum Beispiel abhängig vom Wert verschieden formatieren kann (negative Zahlen rot, positive Zahlen schwarz,...) XML Daten für verschiedene Devices formatieren kann (Bildschirm, Drucker,...) XSL kann aus den XML Daten nicht nur (neue) XML- Files oder XHTML- Files, sondern beliebige Formate erzeugen. XSL wird oft auch verwendet, um die Daten des XML- Dokuments anders zu strukturieren (zum Beispiel passend zu einem anderen Schema oder DTD). Obwohl XSL eigentlich aus drei Teilen mit drei verschiedenen Namen zusammengesetzt ist, wird oft einfach für alles der Name XSL benutzt. Eine Transformationssprache --> XSLT (XSL Transformation) Eine Adressierungssprache --> XPath (Adressieren und Selektieren) Eine Formatierungssprache --> XSL-FO (XSL Formatting Objects) 67

8 8 Die Transformations-Sprache XSLT XSLT ist der wichtigste Teil des XSL Standards. XSLT wird benutzt, um XML Dokumente in andere XML-, HTML-,... Dokumente umzuformen. XSLT kann auch neue, nicht im XML-Dokument enthaltene Daten-Elemente in das Ausgabe- Dokument einfügen (zum Beispiel Formatier-Befehle), Elemente umsortieren oder weglassen XSLT kann die XML-Knoten (zum Beispiel auch abhängig com Wert des Elementes) unterschiedlich behandeln. 8.1 Wie funktioniert XSLT? Ein XSL File besteht aus Regeln (Templates), welche bestimmen, wie die einzelnen Knoten eines XML- Dokuments umgeformt werden sollen. XSLT benutzt im Transformations-Prozess die Sprache XPath, um die zu einer Regel (Template) passenden Knoten des XML Dokuments heraus zu filtern. Wenn im XML- Dokument ein passender Knoten (match) gefunden wird, formt XSLT diesen Knoten mit Hilfe der angegebenen Regel um, und schreibt das Resultat ins Ausgabe-Dokument. Alle Text-Knoten des XML- Dokumentes, welche nicht zu einer Regel passen, werden unmodifiziert in das Ausgabe-Dokument kopiert (vgl. Default Template Rules). 68

9 Das Beispiel Dokument: People.xml <?xml version="1.0"?> <people> <person> <name> <firstname>alan</firstname> <lastname>turing</lastname> </name> <born date="1912" addressref="gbl"/> <died date="1954" addressref="gbc"/> <profession>computer scientist</profession> <profession>mathematician</profession> <profession>cryptographer</profession> <hobby>philosophy</hobby> <hobby>biology</hobby> </person>... Das vollständige XML- Dokument finden Sie auf dem Zusatzblatt. Verbinden mit einem Stylesheet Im XML Dokument kann mit Hilfe der Prozess-Instruktion <?xml-stylesheet...?> das zu verwendende XSL-Stylesheet angegeben werden. <?xml version="1.0"?> <?xml-stylesheet type="text/xsl" href=" <people> <person> <name> <firstname >Alan</firstName> <lastname>turing</lastname> </name>... Falls das XML-Dokument nicht statisch zu einem Stylesheet verbunden werden soll, kann zum Beispiel auch ein kleines Javaskript geschrieben werden, welche die beiden Teile verbindet. Die URL des Stylesheets kann relativ sein, also z.bsp. href="mystyle.xsl" (wie im obigen Beispiel) als absolute Adresse. 69

10 8.2 Der Aufbau eines Stylesheets: Templates XSL benutzt Templates (Regeln), um zu bestimmen, wie die XML-Knoten umgeformt werden sollen. Ein "match"-attribut wird benutzt, um ein Knoten einem Template zuzuordnen. <xsl:template match= Knoten > Action Der Befehl xsl:template legt zuerst die Liste (sequence) aller Knoten des XML-Dokuments an, welche durch match adressiert werden. Die Elemente der Liste werden dann der Reihe nach gemäss den Regeln in Action transformiert. Die Sprache XPath dient hier zur exakten Adressierung der Knoten (welche Knoten sollen umgeformt werden). Das Resultat von Action (der Transformation) wird in das Ausgabe-Dokument geschrieben. Ein erstes XSL Beispiel: hello world Da das Stylesheet selber auch ein XML Dokument ist, fängt es mit einer xml-deklaration an: <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <xsl:output method="text" encoding="utf-8"/> <xsl:template match="people"> hello world </xsl:stylesheet> Der xsl:stylesheet Befehl in der zweiten Zeile ist der eigentliche Start des Stylesheets. Der Namespace URI für xsl muss genau so angegeben werden. Das <xsl:template> Element definiert den Start eines Templates. Das Template Attribute match="people" adressiert das (alle) people-element(e) des XML- Dokumentes. Zwischen dem Start- und dem End-Tag von xsl:template stehen die Anweisungen, welche für das adressierte Element auszuführen sind. Das Tag <xsl:output> definiert, wie das Output File aussehen soll. Hier ist die Ausgabe ein UTF-8 codiertes Text- File. Die Ausgabe des Stylesheets ist hello world. 70

11 Fortsetzung: hello world Wir ergänzen das obige Beispiel um eine weitere Regel: <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <xsl:output method="text" encoding="utf-8"/> <xsl:template match="people"> hello world <xsl:template match="person"> I am here </xsl:stylesheet> Trotz der zusätzlichen Regel für person lautet die Ausgabe wiederum bloss hello world. Damit die zweite Regel ausgeführt wird, müsste sie im people-template explizit aufgerufen werden. Fortsetzung: hello world Wir löschen die people Regel aus dem obigen Beispiel: <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <xsl:output method="text" encoding="utf-8"/> <xsl:template match="person"> I am here </xsl:stylesheet> In diesem Stylesheet fehlt die people-regel. Das bedeutet, dass die Default Regel zum Einsatz kommt, welche alle (direkten) Nachfolger des Root-Knotens (people) sucht, im Stylesheet nach Regeln dafür sucht, und diese ausführt. Da das people Element mehrere person und address Kinder hat, werden person und address Regeln gesucht und ausgeführt. Die "person"- Regel wird für jedes gefundene <person>- Element ausgeführt. Es gibt im Stylesheet keine Regel für address-elemente, also wird die Default Regel ausgeführt. Diese kopiert alle Text-Kinder von <address> (vgl. Kapitel: Default Template Regeln) Die Ausgabe ist darum: I am here I am here I am here I am here Great Britain London Germany Ulm USA Queens, NY Switzerland Basel Great Britain Cambridge USA Princeton 71

12 8.3 Die wichtigsten XSLT Befehle Es kann hier nur eine Auswahl von XSL Befehlen und Konstrukten behandelt werden. Die ganze Liste der Befehle mit Beispielen finden Sie zum Beispiel auch unter xsl:apply-templates, xsl:call-template, xsl:for-each Welches Kind als nächstes behandelt werden soll, kann explizit durch ein select-attribut ausgewählt werden <xsl:apply-templates select="person"/> Der Befehl xsl:apply-templates sucht im XML den angegebenen Pfad, eine Regel dazu und führt diese aus. Der Befehl <xsl:apply-templates/> sucht alle Kind (-Elemente) des aktuellen Knotens und führt deren Templates aus. (Mit "Kind" sind jeweils nur die direkten Nachfolger gemeint). Beispiele: <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <xsl:output method="text" encoding="utf-8"/> <xsl:template match="people"> <xsl:apply-templates select="person"/> <xsl:template match="person"> I am here </xsl:stylesheet> Die gleiche Ausgabe erhalten wir durch Aufruf der folgenden Templates: <xsl:template match="people"> <xsl:call-template name="templ1"/> <xsl:template name=" templ1"> <xsl:apply-templates select="person"/> <xsl:template match="person"> I am here Oder als dritte Möglichkeit: <xsl:template match="people"> <xsl:for-each select="person"> I am here </xsl:for-each> 72

13 xsl:value-of Das XSL <xsl:value-of> Element kann benutzt werden, um den Wert bestimmter Knoten auszugeben. Beispiele: <xsl:value-of select="lastname"/> <xsl:value-of select="firstname"/> <xsl:value-of select="hobby" separator=", " /> value-of berechnet den Wert eines Ausdrucks oder XML Knotens nach den folgenden Regeln: Element: der Text-Inhalt eines Elementes, nachdem alle Referenzen aufgelöst sind. Text: der Text selber Attribut: der Wert des Attributes <xsl:value-of select=". "/> gibt den Wert des aktuellen Knotens zurück. <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <xsl:output method="xhtml" encoding="utf-8"/> <xsl:template match="people" > <html> <head> <title>famous Scientists</title> </head> <body> <h3> Famous Scientists</h3> <xsl:apply-templates select="person"/> </body> </html> Die Ausgabe der Transformation: <html> <head><title> Famous Scientists</title></head> <body> <h4> Famous Scientists</h4> <p>turing Alan</p> <p>feynman Richard</p> <p>einstein Albert</p> <p>euler Leonhard</p> </body> </html> <xsl:template match="person"> <p><xsl:apply-templates select="name"/></p> <xsl:template match="name"> <xsl:value-of select="lastname"/> <xsl:text> </xsl:text> <xsl:value-of select="firstname"/> </xsl:stylesheet> Das obige XSL-Stylesheet erzeugt ein HTML-Dokument. Die HTML-Tags gehören nicht zu XSL. Sie werden darum einfach in die Ausgabe kopiert (literal result element). Das people Template verpackt den Output in ein HTML-Dokument, mit head, title und body. Danach wird das person Template aufgerufen. Das person- Template fängt einen neuen Abschnitt an (<p>) und ruft das name- Template auf. Im name Template wird durch das <xsl:text> Element sichergestellt, dass zwischen dem Namen und dem Vornamen ein Abstand (Space) eingefügt wird. <xsl:text>mytext</xsl:text> kopiert den String mytext (unverändert) in das Ausgabe-Dokument (inkl. Whitespace). 73

14 Adressieren von Attributen Für das Adressieren von Attributen wird das verwendet. <xsl:value-of select= born/@date /> liefert den Wert des date Attributes im born Element. <xsl:template match="person"> <b><xsl:apply-templates select="name"/></b> <xsl:text> </xsl:text> <small> ( <xsl:value-of select="born/@date"/> - <xsl: value-of select="died/@date"/>) </small> <p/> Template mit Modes Es ist möglich, für denselben Knoten mehrere verschiedene Templates zu definieren, die dann kontextabhängig angewendet werden. Der Aufruf des Templates sowie das Template selber erhalten ein mode Attribute. Damit können zum Beispiel Inhaltsverzeichnisse, Querverweise oder verschiedene Darstellungen der gleichen Datenelemente erzeugt werden. <xsl:stylesheet version="1.0 " xmlns:xsl=" <xsl:template match="people"> <html> <head> <title> Famous Scientists</title> </head> <body> <h3> Famous Scientists, Mode</h3> <h4> Table of Contents </h4> <ul> <xsl:apply-templates select="person" mode ="toc"/> </ul> <xsl:apply-templates select="person"/> </body> </html> Der erste Durchgang wird durch <xsl:template match="person" mode="toc"> gebildet, der zweite durch <xsl:template match="person"> <xsl:template match="person" mode ="toc"> <xsl:apply-templates select="name" mode="toc"/> <xsl:template match="person"> <p> <xsl:apply-templates select="name"/> <small> (<xsl:apply-templates select="born/@date"/> - <xsl:apply-templates select="died/@date"/> ) </small> </p> <xsl:template match="name" mode ="toc"> <li> <xsl:value-of select="lastname"/> </li> <xsl:template match="name">... --> vgl. Beispiel vorher </xsl:stylesheet> 74

15 xsl:if <xsl:if test="lastname = 'Euler'">... </xsl:if> filtert nur die Elemente mit lastname gleich Euler. <xsl:if test="born/@date > 1900" >... </xsl:if> behandelt nur die Personen, welche nach 1900 geboren sind. Im Template: <xsl:template match="person"> <xsl:if test="born/@date > 1900 "> <xsl:apply-templates select="name"/> </xsl:if> Die Bedingungen können mit Hilfe von and oder or verbunden werden. <xsl:template match="person"> <xsl:if test="born/@date > 1850 and name/firstname!= 'Alan' "> <xsl:apply-templates select="name"/> </xsl:if> Das Template gibt nur die Namen der Personen aus, welche später als 1900 geboren sind. Komplizierte Bedingungen können mit runden Klammern gruppiert werden: (... and... ) or (... or... <xsl:template match="person"> <xsl:if test="born/@date > 1900 or (name/firstname = 'Leonhard' and name/lastname='euler')" > <xsl:apply-templates select="name"/> </xsl:if > 75

16 xsl:choose Es gibt in XSL kein if-else Konstrukt. Anstatt eines if-else gibt es ein xsl:choose. Verzweigungen werden aus xsl:when und xsl:otherwise zusammengesetzt. <xsl:choose> <xsl:when test="...">... </xsl:when> <xsl:otherwise>... </xsl:otherwise> </xsl:choose> xsl:choose ist vergleichbar mit einem Switch-Case-Statement in Java oder C++. Nur der erste when-ast, welcher zu true evaluiert, wird ausgeführt. Falls keiner der when-tests zu true evaluiert, wird otherwise ausgeführt. Ein Beispiel <xsl:template match="people">... vgl. Beispiel vorher <xsl:apply-templates select="person"/>... <xsl:template match="person"> <xsl: choose > <xsl: when test="profession='mathematician' "> <font color="blue"> <xsl:apply-templates select="hobby"/> </font> </xsl: when > <xsl: when test="profession='cryptographer' "> <font color="red"> <xsl:apply-templates select="hobby"/> </font> </xsl: when > <xsl: otherwise > <xsl:apply-templates select="hobby"/> </xsl: otherwise > </xsl: choose > blau für Mathematiker rot für Kryptologen sonst schwarz <xsl:template match="hobby"> <li><xsl:value-of select="."/></li> 76

17 xsl:sort Um eine Sequenz von Knoten während der Transformation (nach einem gewählten Schlüssel) zu sortieren, gibt es das sort Element: <xsl:sort select="name/lastname"/> xsl:sort kann entweder innerhalb eines <xsl:apply-templates> oder eines <xsl:for-each> Elements vorkommen. Das select-attribut gibt an, nach welchem Schlüssel sortiert werden soll. Falls numerisch sortiert werden soll (der Sortier-Schlüssel eine Zahl ist) muss dies mit dem data-type Attribut angegeben werden: <xsl:sort select = "..." data-type="number" /> Beispiel: Sortieren mit xsl:apply-templates oder mit xsl:for-each <xsl:template match="people"> <html> <head> <title> Famous Scientists, xsl:sort</title> </head> <body> <h3>famous Scientists</h3> <xsl: apply-templates select="person"> Alle Personen sortiert aufzählen <xsl:sort select="name/lastname" order="ascending"/> </xsl:apply-templates> <br/> <b>hobbies of the Famous</b> <ul> <xsl: for-each select="person/hobby"> Alle Hobbies sortiert aufzählen <xsl:sort select="." order="descending"/> <li><xsl:value-of select="."/></li> </xsl:for-each> </ul> </body> </html> Der apply-templates Befehl sammelt alle Knoten unter dem XPath (hier person). Der Sort-Befehl bewirkt, dass alle person-elemente vor deren Verarbeitung nach ihrem Namen sortiert werden. Der for-each Befehl sammelt hier alle Hobby Elemente aller Personen und sortiert sie vor deren Ausgabe. 77

18 xsl:variable In XSL können auch Konstanten definiert werden: <xsl:variable name="ntext"> value_of_variable </xsl:variable> Der Wert der Konstanten ntext kann mit $ntext gelesen werden: <xsl:value-of select="$ntext"/> Der Wert von ntext kann dann nicht mehr verändert werden! Dies sind keine Variablen, wie man sie in C++ oder Java kennt, sondern eher von der Art der Variablen wie man sie im funktionalen Programmieren kennt (benannte Konstanten). Trotzdem können diese Variablen sehr nützlich sein. Beispiel: Berechnen einer gewichteten Summe Wir nehmen das Beispiel einer Bestellung. <?xml version="1.0"?> <order> <book> <title>xml</title> <price>24.20</price> <quantity>2</quantity> </book> <book> <title>uml</title> <price>43.20</price> <quantity>1</quantity> </book> <book>... </book> </order> Von dieser Bestellung wollen wir den Gesamt-Preis berechnen. <xsl:template match="totalbetrag"> <xsl:variable name="tmp"> <tmpprice> <xsl:for-each select="book"> <item> <xsl:value-of select="price * quantity"/> </item> </xsl:for-each> </tmpprice> </xsl:variable> <xsl:value-of select="sum($tmp/tmpprices/item)"/> Der Inhalt der Variablen tmp ist dann: Der sum Befehl zählt diese Werte zusammen. 78

19 Auflösen von key / keyref Paaren mit Hilfe von Variablen <xsl:template match="born"> <xsl:value-of select="../name/lastname"/>, <xsl:value-of select="name()"/> <xsl:text> </xsl:text> <xsl:value-of select="@date"/> <xsl:text> in </xsl:text> <xsl:variable name="myref" select="@addressref"/> Address-ID in der Variable abspeichern <xsl:value-of select="//address[@id=$myref]/city"/> die gefundene Adresse ausgeben Dieses Vorgehen ist allerdings nicht effizient. Wir werden später ein besseres Verfahren kennen lernen. xsl:param Beim Aufruf von Templates können Parameter übergeben werden: <xsl:apply-templates select="title"> <xsl:with-param name="p1"> <xsl:value-of select="irgendein Wert"/> </xsl:with-param> </xsl:apply-templates> Verwendung im Template: <xsl:template match="title"> <xsl:param name="p1"/>... verwenden von $p1... Es können auch mehrere Parameter übergeben werden: <xsl:template match="people"> <xsl:apply-templates select="person"> <xsl: with-param name="a1"> <xsl:value-of select="address[1]/city"/> </xsl:with-param> <xsl: with-param name="a2"> <xsl:value-of select="address[2]/country"/> </xsl:with-param> </xsl:apply-templates> Der Wert der Parameter kann im Template (analog zu den Variablen) mit $a1, bzw. $a2 gelesen werden. Ausserdem kann ein Default-Wert angegeben werden, falls im Aufruf ein Parameter fehlt. <xsl:template match="person"> <xsl:param name="a1"/> beide Parameter einlesen <xsl:param name="a2"> Germany Default Wert für a2 </xsl:param> <xsl:value-of select="name/lastname"/> <xsl:value-of select="$a1"/> <xsl:value-of select="$a2"/> 79

20 xsl:for-each-group Das folgende Template gibt alle Adressen gruppiert nach Ländern aus. Adressen aus dem selben Land werden durch ein Komma separiert. <xsl:template match="people"> <xsl:for-each-group select="address" group-by="country"> <xsl:value-of select="country"/>: <xsl:value-of select="current-group()/city" separator=", "/> <br/> </xsl:for-each-group> Die Ausgabe ist dann: Great Britain: London, Cambridge Germany: Ulm USA: Queens, NY, Princeton Switzerland: Basel Importieren von Stylesheets Die Befehle <xsl:import href="uri"> und <xsl:include href="uri"> fügen das unter der angegebenen Adresse gefundene Stylesheet ein. Der Pfad kann dabei relativ <xsl:include href="ss.xsl"/> oder absolut sein: <xsl:include href=" Eingefügte Stylesheets können selber ebenfalls wieder mit xsl:include oder xsl:import andere Stylesheets einlesen (Vorsicht: Zyklen!). Beim Transformieren werden sowohl die Regeln des importierten als auch des importierenden Stylesheets angewandt. Durch <xsl:import> werden die Regeln beider Stylesheets benutzt. Falls sich Regeln widersprechen wird die Regel des lokalen Stylesheets benutzt. <xsl:include> kopiert den Inhalt des angegebenen Stylesheets in das einlesende Stylesheet. Falls sich Regeln widersprechen (durch Templates mit gleichen Namen oder gleichen Pattern), tritt normalerweise ein Fehler auf. 80

21 9 Grundlegendes zu XSLT 9.1 Default Template Regeln Was geschieht mit den Knoten, wenn es im Stylesheet dafür kein Template gibt? Auch wenn im Stylesheet keine explizite Regel für die Behandlung eines Knotens angegeben ist, gibt es (abhängig vom Typ des Knotens) eine Regel für diesen Knoten. Es gibt sieben Typen von Knoten in XML-Dokumenten Root-Knoten Element-Knoten Attribut-Knoten Text-Knoten Kommentar-Knoten Verarbeitungs-Anweisungen (Processing-Instructions) Namespace-Knoten Für jeden Knoten-Typ gibt es eine Default Template Regel, welche angibt, was mit einem solchen Knoten passieren soll, falls im Stylesheet keine Regel dafür vorhanden ist. Text- und Attribut-Knoten Von Text- und Attribut-Knoten wird der Wert des Textes (des Attributes) in das Ausgabe-Dokument kopiert. Als XSL-Template sieht dies wie folgt aus: <xsl:template match= " "> <xsl:value-of select="."/> Wir können uns vorstellen, dass in jedem Stylesheet diese Regel mit drin steht (auch wenn sie nicht explizit vorhanden ist). Die folgende Regel: <xsl:template match="name"> <xsl:apply-templates select="firstname"/> <xsl:text> </xsl:text> <xsl:apply-templates select="lastname"/> sagt zum Beispiel nichts darüber aus, was mit dem (Text-) Inhalt des firstname-, bzw. lastname-knotens (Alan, Euler, Turing,...) geschehen soll (falls es kein entsprechendes Template gibt). Falls es für firstname oder lastname keine Regel im Stylesheet gibt, wird automatisch die Default-Regel angewandt, welche den Text (Alan, Euler, Turing,...) unverändert in die Ausgabe kopiert. 81

22 Root- und Element-Knoten Vom Root- und von allen Element-Knoten werden per Default die Template-Regeln aller Kindknoten aufgerufen. Als XSL-Template sieht dies wie folgt aus: <xsl:template match= " / * "> <xsl:apply-templates/> Falls es also im Stylesheet keine Regel für das Root-Element oder für "/" gibt, wird die Regel für dessen Kind-Knoten gesucht und ausgeführt. Falls es im Stylesheet für einen beliebiges Element keine Regel gibt, werden ebenfalls dessen Kind-Knoten gesucht und deren Regeln ausgeführt. Kommentare und Verarbeitungsanweisungen Falls es keine explizite Regel dafür gibt, werden Kommentare und Processing Instructions nicht ausgegeben. Als XSL-Template sieht dies wie folgt aus: <xsl:template match= "processing-instructions() comment()" /> Es gibt keine Adressierung (keinen XPath Ausdruck) für Namespace-Knoten. Kommentare, Namespaces und Verarbeitungsanweisungen machen im Ziel Dokument normalerweise keinen Sinn mehr. 82

23 9.2 Template Driven vs. Data Driven Stylesheets In allen Beispielen, welche wir bisher betrachtet haben, bestimmt das Template im Stylesheet, welche Regel als nächstes benutzt werden soll. Diesen Programmierstil bezeichnet man als Template-Driven. Dies ist immer dann sinnvoll, wenn die Source Dokumente stark struktuiert sind. Daten-bezogene XML- Dokumente sind üblicherweise stark strukturiert. Anders sieht es aus, wenn die XML Dokumente keinen strikten Aufbau haben. Dies findet man zum Beispiel in Dokumenten, welche Texte, Briefe oder Webseiten Inhalte beschreiben. Ein Beispiel XML Dokument, ohne strikten Aufbau <?xml version='1.0'?> <book-review> <title>this Book</title> by <author>this Author</author>, published by <publisher>the Publisher</publisher> on <date>date</date>, is indeed a good book. However, the book titled <title> Bad Book</title> by the same publisher is very bad. The reviewer is left to wonder whether this is because <title>bad Book</title> was written by <author>bad Author</author>, or because it was published on <date>date</date>. </book-review> Für solche Dokumente ist es sehr schwierig, im Stylesheet die Reihenfolge der zu benutzenden Templates festzulegen. Viel einfacher ist es, das Stylesheet Data-Driven zu implementieren: d.h. xsl:apply-templates ohne select-attribut. Im folgenden Stylesheet bestimmt allein das XML Dokument, in welcher Reihenfolge die Regeln aufgerufen werden. <xsl:stylesheet version="1.0" xmlns:xsl=" <xsl:template match="/"> <html><body> <xsl:apply-templates/> </body></html> <xsl:template match="book-review"> <p> <xsl:apply-templates/> </p> <xsl:template match="title"> <span style="font-weight:bold"> <xsl:value-of select="."/> </span> <xsl:template match="author"> <span style="font-style:italic"> <xsl:apply-templates/> </span> <xsl:template match="publisher"> <span style="color:blue"> <xsl:apply-templates/> </span>... </xsl:stylesheet> Die Ausgabe Die beiden Modelle (Template-Driven und Data-Driven) lassen sich in einem Stylesheet nach Bedarf mischen. 83

24 10 XPath: Die XSL Adressierungssprache Die Templates im Stylesheet können nur dann richtig (an der richtigen Stelle) angewandt werden, wenn die Adressierung (match) korrekt ist. XSL muss beliebige Knoten des XML-Dokumentes adressieren (identifizieren) können. Dafür benutzt XSL die Sprache XPath. Die W3C Spezifikation für XPath finden Sie unter Einige Beispiele name alle <name> Kinder des aktuellen Knotens name/firstname alle <firstname> Kinder aller / der Root Knoten des Dokumentes. der aktuelle Knoten.. der Vorgänger (Parent) des aktuellen Knotens //name alle <name> Elemente des Dokumentes <name> Kinder des aktuellen Knotens.//name alle <name> Nachfolger (direkte und indirekte) des aktuellen Knotens //name/firstname alle <firstname> Elemente, welche Nachfolger von <name> sind. // ist die Abkürzung für descendant-or-self, d.h. für alle direkten und indirekten Nachfolger, sowie den Knoten selber Die XPath Syntax Die XPath-Syntax sieht ähnlich aus wie die übliche Filesystem-Adressierung. Das Pattern matching ist abhängig vom Kontext: Ein XPath Ausdruck kann verschiedene Knoten bezeichnen, abhängig von der Stelle im Dokument, in welchem er steht. XPath findet alle passenden Knoten. Sollen nur gewisse Knoten aus dem Pfad selektiert werden, kann der Pfad (durch Prädikate) eingeschränkt werden. Ein XPath ist absolut, falls er mit einem Slash (" / ") anfängt, z.b. /person Ein Pfad ist zusammengesetzt auf einer Reihe von Schritten, welche durch "/" getrennt sind: people/person/born Attribute werden durch "@" markiert. born/@addressref Pfade können kombiniert werden durch " " (Auswahl) name/firstname profession hobby 84

25 Wildcards Pfade können die Wildcards und node() enthalten. * selektiert alle selektiert alle Attribute node() selektiert alle Knoten Attribute, Text-Knoten, Kommentare oder Verarbeitungsanweisungen (Processing-Instructions) werden durch den Stern (*) nicht selektiert nur Attribute node() selektiert alle Knoten: Elemente, Attribute, Text-Knoten, Kommentare, Verarbeitungsanweisungen, Beispiele //* findet alle Elemente im Dokument /* alle Kinder von Root (also das Root-Element) str/*/title alle <title> Enkel von str //*/@id alle Attribute mit Namen id //*/@* alle Attribut Knoten im Dokument. XPath Prädikate XPath kann auch filtern. Dazu wird im select-attribut zum Pfad ein Prädikat mit angegeben <xsl:apply-templates select="person[name/firstname!= 'Alan']"/> Mögliche Filter-Operatoren sind: = gleich!= ungleich < kleiner als > grösser als XPath Filter können xsl:if Statements ersetzen und sind oft eleganter und effizienter. Prädikate können in select Attributen, aber auch in match Attributen verwendet werden: Die Regel <xsl:template match= person[@id] > gilt nur für person-elemente, welche ein id-attribut haben. (Vorsicht: für die anderen person-elemente benötigen Sie also eine separate Regel!) XPath Prädikat Beispiele: = 'gbc' ] alle <born> Kinder, welche ein addressref Attribut mit Wert "gbc" haben ] alle <died> Kinder, welche ein addressref Attribut haben person [born/@date > 1900 ]/name alle Namen von Personen, welche später als 1900 geboren sind name[last()] das letzte <name> Kind des aktuellen Knotens 85

26 Zu beachten ist, dass die Adressierungen vom Kontext abhängig sind: gibt nur dann ein Element zurück, wenn der aktuelle Knoten (Kontext) ein oder mehrere died Kinder hat, welche ein addressref Attribut haben. Doppelte Einschränkungen (nacheinander ausgeführt) gibt das letzte name-element zurück, falls dieses ein addressref- Attribut hat. gibt das letzte name-element zurück, welches ein addressref-attribut hat. XPath Schritte Jeder Schritt im Pfad ist ein Bezeichner, ein Wildcard oder ein Prädikat. <xsl:template match="person"> <xsl:apply-templates <xsl:template match="born died"> <xsl:value-of select="../*/lastname"/>, <xsl:value-of select="name(.)"/>: <xsl:value-of <xsl:variable name="var" <xsl:apply-templates <br/> <xsl:template match="city"> in <xsl:value-of select="."/> Die verwendeten Bezeichner --> people, Wildcards --> node() Prädikate Der Pfad wählt alle Kind-Knoten von person aus, welche ein date Attribut haben. Der Pfad // * [@id = $var] wählt alle Elemente Dokumentes aus, welche ein id-attribut haben, welches den gleichen Wert hat wie var (bzw. den gleichen Wert Gefunden werden die address Elemente und es wird der Inhalt des <city>-elements ausgegeben. Weitere Beispiele von Pfaden mit Prädikaten: //name/* //name/*[@*] alle Kinder von name alle Kinder von name, die ein Attribut haben //name/*[*] alle Kinder von name, welche keine Blätter sind //*[@*] alle Elemente, die ein Attribut haben //person[*/@id]/name alle name Kinder von person Elementen, die ein Kind mit einem id Attribut haben //*[@*]/* alle Kinder von Elementen, die ein Attribut haben 86

27 87

28 10.2 Adressierungs-Achsen preceding-sibling sind alle früheren, following-sibling alle im Dokument nachfolgenden Geschwister-Knoten von self. Die Begriffe preceding und following beziehen sich auf die Reihenfolge im XML-Dokument. following sind alle Knoten, welche im XML-Dokument hinter dem End-Tag des self-knoten stehen. preceding sind alle Knoten, die vor dem Start-Tag des self-knoten stehen und keine ancestors sind. Beispiele: child::people alle <people>-kinder des aktuellen Knotens following-sibling::profession alle <profession>- Geschwister des aktuellen Knotens, welche im XML- File später auftreten. descendent::* alle (direkten und indirekten) Nachfolger des aktuellen Knotens ancestor::*/child::person alle <person> Kinder aller Vorgänger Knoten des aktuellen Knotens Für die wichtigsten Adressierungs-Achsen existieren (die bereits bekannten) Abkürzungen: child (leer) parent.. self. descendant-or-self // Die Bezeichnung "child::" kann immer weggelassen werden. /child::people/child::person/child::profession = /people/child::person/profession = /people/person/child::profession self wird vor allem im Zusammenhang mit value-of benutzt: <xsl:value-of select=" self::* "/> ist gleichbedeutend mit <xsl:value-of select=". "/> descendant-or-self kann absolut oder relativ verwendet werden: <xsl:apply-templates select= "//lastname />, d.h. alle lastname Elemente des Dokuments <xsl:apply-templates select= "person//lastname />, d.h. nur die lastname Nachfolger von person. Das Template <xsl:apply-templates select= "//lastname[string-length(text()) > 6]/.. "/> findet zum Beispiel alle parent Knoten von allen lastname Elementen, deren Text-Inhalt mehr als 6 Buchstaben lang ist. 88

29 10.3 Die wichtigsten XPath Funktionen Die W3C Recommendation zu XQuery 1.0 and XPath 2.0 Functions and Operators finden Sie unter Ausserdem finden Sie alle von saxon8 unterstützten XPath 2.0 Funktionen und Operatoren unter Einige Beispiele boolean( obj ), number( obj ), string( obj ) konvertiert das object obj falls möglich zu einem boolean/number/string... boolean(0) ist falsch, boolean(5) ist wahr boolean(nan) ist falsch, also auch boolean(number('a')). (NaN steht für not a Number.) boolean not (value) gibt true zurück, falls value zu false evaluiert (und umgekehrt). Funktionen auf Strings String concat( String s1, String s2, String s3,... ) setzt die Strings s1, s2, s3,... zusammen String substring(string s1, double start, double length) gibt den Teil-String von s1 ab Position start mit Länge length zurück. boolean contains( string s1, string s2 ) gibt true zurück, falls s2 ein Substring von s1 ist number string-length( string ) gibt die Länge des Strings zurück string translate( string s, string s1, string s2 ) ersetzt alle Vorkommnisse von s1 in s durch s2. boolean matches(string, pattern) gibt true zurück, falls der gegebene String das Pattern erfüllt. String replace(string1, pattern, string2) ersetzt in string1 alle Teile, welche das pattern erfüllen durch string2. Numerische Funktionen number abs(number), number avg(number), number max(items), number min(items) Absolutwert, Durchschnitt, Maximum, Minimum number round(number), number ceiling(number), number floor(number) Runden, Aufrunden, Abrunden atomictype sum(atomictype) summiert die Werte aller Werte auf. atomictype ist muss hier eine Zahl oder eine Zeitdauer (duration) sein. Falls ein Argument-Knoten von sum keine Zahl oder Zeitdauer ist, ist der Rückgabe-Wert "NaN" (Not a Number). sum(//number) summiert alle Werte unter //number, sum(//book/quantity) berechnet also zum Beispiel die Anzahl vorhandener Bücher. String format-number(value, picturestring) formatiert den value gemäss dem picturestring. format-number(500100, ' #.0 ') Ausserdem existieren die normalen Grundoperationen +, -, *, mod und div. 89

30 Funktionen auf Sequenzen (Listen von Knoten) number last() berechnet die Anzahl Knoten im Kontext //person[1] gibt die erste, //person[last()] gibt die letzte Person zurück. number position() gibt die Position des Kontext Knotens in der aktuell verarbeiteten Sequenz zurück. Während dem Abarbeiten der Sequenzen wir die Position laufend aktualisiert. Falls die Personen gefiltert oder sortiert werden, liefert position dennoch eine normale aufsteigende Nummerierung. number count( items) zählt die Knoten in der Sequenz items. z.b. count(//person) gibt 4, count(//address) gibt 6 zurück. remove(...), insert-before(...), reverse(...), subsequence(...) sind Funktionen auf Sequenzen zum Löschen, Einfügen, Umdrehen und Zerteilen der Sequenzen. boolean empty(items) true, falls items eine leere Sequenz ist. Datum und Zeit date current-date(), datetime currenttime() gibt das aktuelle Datum, bzw. die aktuelle Zeit zurück. Dieses kann nachher durch format-date(), bzw. format-datetime() formatiert werden. String format-date(date, picturestring) formatiert das Datum date gemäss picturestring. format-date(current-date(), ' [D]-[M]-[Y] ') for Ausdrücke Mit Hilfe von for Ausdrücken ist es möglich, in einem XPath Aufruf über alle Elemente der ganzen Sequenz zu iterieren. Die Syntax benutzt eine Iterator-Variable (hier z.b. x). Aus einem for $x in E return result evaluiert result für jedes Element der Sequenz E <xsl:value-of select="sum(for $x in book return $x/price * $x/quantity)"/> summiert die price * quantity Werte aller book Elemente auf. 90

31 Einlesen von XML Dokumenten Die Funktion document($srcval ) lädt das an der Adresse (URI) srcval gefundene Dokument. Durch Definition einer (globalen) Variable "input" kann folgendermassen auf die Elemente des Files "Daten.xml" zugegriffen werden. <xsl:variable name="input" select="document('daten.xml')/person"/> Diese Variable kann dann benutzt werden um die Namen der Personen im Daten File zu lesen: <xsl:value-of select="$input/name"/> xsl:key und key()-funktion Durch xsl:key kann eine Indexierung (Schlüssel) von Elementen angelegt werden. Dies erzeugt eine Hash-Tabelle, über deren Schlüssel auf die Werte zugegriffen werden kann. Die key-funktion hat zwei Auswirkungen: Sie kann den xsl-code vereinfachen und sie kann die Performance positiv beeinflussen, indem der Parser eine Indexierung für alle key-werte anlegt. Alle../born/@date-Attribute werden als Schlüssel für die name-elemente abgelegt: <xsl:key name="mykey1" match="name" use="../born/@date"/> Alle hobby-elemente werden unter ihrem Anfangsbuchstaben abgelegt: <xsl:key name="mykey2" match="hobby" use="substring(.,1,1)"/> Die XPath Funktion key() gibt dann die entsprechenden Elemente zurück. <xsl:apply-templates select="key('mykey1','1912')"/> gibt alle name-knoten mit Geburtstjahr 1912 zurück. <xsl:apply-templates select="key('mykey2','p')"/> gibt alle hobby-knoten mit Anfangsbuchstabe "p" zurück. 91

32 Ein Beispiel <?xml version="1.0" encoding="utf-8"?> <xsl:stylesheet version="2.0" xmlns:xsl=" <-- indexieren aller Personennamen nach Datum --> <xsl:key name="namekey" match="name" <-- indexieren aller Hobbys nach Anfangsbuchstaben --> <xsl:key name="hobbykey" match="hobby" use="substring(.,1,1)"/> <-- indexieren aller Adressen nach ihrer id --> <xsl:key name="addrkey" match="address" <xsl:template match="people"> <html> <body> <!-- Geburtsjahr und Ort, absteigend sortiert auflisten --> <ul> <xsl:for-each <xsl:sort order="descending"/> <li> <xsl:value-of <xsl:text> </xsl:text> <xsl:value-of <xsl:if <xsl:text>, </xsl:text> <xsl:value-of select="name()"/> in <!-- zum Datum die entsprechende Adresse ausgeben. --> <xsl:value-of <xsl:text> </xsl:text> <!-- und das Datum selber --> <xsl:value-of </xsl:if> </li> </xsl:for-each> </ul> <!-- alle Hobbies die mit 'p' anfangen auflisten --> <p> <xsl:value-of select="key('hobbykey','p')" separator=", "/> </p> </body> </html> </xsl:stylesheet> 92

33 xsl:function Beispiele von selber definierten XSL Funktionen <xsl:stylesheet xmlns:xsl=" version="2.0" xmlns:cs=" xmlns:xs=' <xsl:function name="cs:substring"> <xsl:param name="str" as="xs:string"/> <xsl:param name="n" as="xs:integer"/> <xsl:sequence select= "if( string-length($str) >=$n ) then substring($str,1,$n) else error() "/> </xsl:function> <xsl:function name="cs:numberofchildren"> <xsl:param name="node"/> <xsl:sequence select="count($node/*)"/> </xsl:function>... Solche selber definierten Funktionen können dann folgendermassen benutzt werden: <xsl:value-of select="cs:numberofchildren(/people)"/> 93

34 11 XSL-FO Einführung XSL-FO... bildet zusammen mit XSLT und XPath die XSL (extensible Stylesheet Language)... ist eine XML Applikation... definiert das visuelle Layout-Modell... wird mit Hilfe von einem Transformations-Tool (FOP, XEP,...) nach PDF, PostScript,... transformiert Dabei werden normalerweise keine FO-Dokumente direkt geschrieben, sondern die XML Daten werden mit Hilfe eines Stylesheets nach XSL-FO übersetzt, und dann mit Hilfe eines FO-Transformations-Tools nach Postscript, PDF,... transformiert Ein einfaches Beispiel <?xml version="1.0"?> <fo:root xmlns:fo=" <fo:layout-master-set> <fo:simple-page-master master-name="only" page-width="5.5cm" margin-left="1cm"> <fo:region-body/> </fo:simple-page-master> </fo:layout-master-set> <fo:page-sequence master-reference="only"> <fo:flow flow-name="xsl-region-body"> <fo:block font-size="18pt"> A small <fo:external-graphic src="fo.jpg"/> example </fo:block> </fo:flow> </fo:page-sequence> </fo:root>

35 11.2 Die wichtigsten FO Elemente Es gibt 56 XSL-FO Elemente fo:block, fo:block-container, fo:character, fo:external-graphic, fo:flow, fo:footnote, fo:inline, fo:layout-master-set, fo:leader, fo:list-block, fo:list-item, fo:list-item-body, fo:list-item-label, fo:page-number, fo:page-sequence, fo:region-after, fo:region-before, fo:region-body, fo:root, fo:simple-page-master, fo:table-and-caption, fo:table, fo:tablebody, fo:table-caption, fo:table-cell, fo:table-column, fo:table-footer, fo:table-header, fo:table-row,... Die Elemente von XSL-FO definieren die Struktur oder den Aufbau (Unterteilung in Abschnitte, Blöcke, Text- Felder, Bilder,...) des Ausgabe- Dokuments. Die Attribute definieren das (lokale) Aussehen. Das Root Element XSL-FO Dokumente sind XML Dokumente. Darum beginnen FO-Dokumente mit der XML-Deklaration: <?xml version="1.0"?> XSL-FO Dokumente haben als Root-Element einen fo:root Knoten, in welchem der fo Namespace deklariert werden muss: xmlns:fo=" 95

36 Das Layout einer Seite Eine Seite ist aufgeteilt in die fünf Bereiche region-before, region-after, region-start, region-end und regionbody. Diese sehen in der üblichen Lesart (von links nach rechts, von oben nach unten) wie folgt aus: Normalerweise sind die Randbereiche (region-before, region-after,...) reserviert für statische (wiederkehrende) Ausgaben (Logos, Adresse, Seitenzahl,...), während der eigentliche Inhalt der Seite im Zentralbereich (body) ausgegeben wird. Die einzelnen Bereiche können dann weiter aufgeteilt werden in Blöcke (zum Beispiel durch fo:block, fo:table, fo:list-block,...). Das Layout Master Set Das layout-master-set enthält alle Seiten-Vorlagen für die verschiedenen Seiten-Arten wie Titelseiten, linke und rechte Seiten,... <fo:layout-master-set> <fo:simple-page-master master-name="first" page-height="297mm" page-width="210mm" margin-top="15mm" margin-bottom="15mm" margin-left="20mm" margin-right ="15mm"> <fo:region-body margin-top="20mm"/> <fo:region-before extent="15mm" region-name="fbefore"/> </fo:simple-page-master> <fo:simple-page-master master-name="odd"... </...> </fo:layout-master-set> Die einzelnen Seiten-Vorlagen sind dann verpackt in verschiedene page-master Elemente. Das layout-master-set Element hat keine Attribute, ist immer ein Kind-Knoten vom root-knoten und hat als (einzig mögliche) Kinder einen (oder mehrere) simple-page-master oder page-sequence-master Knoten. Mit dem simple-page-master Knoten werden die Seitenränder (margin) und ev. die Papiergrösse festgelegt. Weiter wird definiert, in wie viele Bereiche (regions) die Seite aufgeteilt werden soll (region-body, regionbefore, region-after,...). Die normalen A4 Seitengrösse ist page-height="29.7cm" und page-width="21cm" Pro Seitentyp (Titelseite, Index-Seite, Inhaltsverzeichnis,...) wird je eine separate Seiten-Vorlage definiert. 96

37 Die Platz-Verteilung für die Regionen <fo:root xmlns:fo= " <fo:layout-master-set> <fo:simple-page-master master-name="simple" page-height="10cm" page-width="9cm" margin-top="1.5cm" margin-bottom="1.5cm" margin-left="1cm" margin-right="1cm"> <fo:region-body margin-top="2cm" margin-bottom="1.5cm" background-color="#eeeeee" /> <fo:region-before extent="1cm" background-color="yellow"/> <fo:region-after extent="1cm" background-color="yellow"/> </fo:simple-page-master> </fo:layout-master-set> <fo:page-sequence master-reference="simple"> <fo:static-content flow-name="xsl-region-before"> <fo:block font-size="12pt"> Hier ist der Platz für das Region- Before </fo:block> </fo:static-content> <fo:static-content flow-name="xsl-region-after" > <fo:block font-size="12pt"> Region-After ist oberhalb vom unteren Rand </fo:block> </fo:static-content> <fo:flow flow-name="xsl-region-body"> <fo:block font-size="20pt" padding="0.5cm"> Region Body Region Body Region Body... </fo:block> </fo:flow> </fo:page-sequence> </fo:root> 97

38 Definieren und Benutzen von verschieden Seiten-Typen <fo:root xmlns:fo=" <fo:layout-master-set> <!-- Definition der ersten Seite--> <fo:simple-page-master master-name="erste" margin-left="5cm" margin-right="5cm margin-top="2cm" margin-bottom="3cm"> <fo:region-body margin-top="3cm" margin-bottom="2cm"/> <fo:region-before extent="3cm" region-name="first-before"/> <fo:region-after extent="1.5cm" region-name="first-after"/> </fo:simple-page-master> <!-- Definition der restlichen Seiten--> <fo:simple-page-master margin-bottom="3cm" margin-left="5cm" margin-right="5cm margin-top="5cm" master-name="restliche"> <fo:region-body margin-top="2.5cm" margin-bottom="2cm"/> <fo:region-before extent="2.5cm" region-name="rest-before"/> <fo:region-after extent="1.5cm" region-name="rest-after"/> </fo:simple-page-master> <!-- Wann soll welche Definition benutzt werden --> <fo:page-sequence-master master-name="global"> <fo:repeatable-page-master-alternatives> <fo:conditional-page-master-reference master-reference="erste" page-position="first"/> <fo:conditional-page-master-reference master-reference="restliche" page-position="rest"/> <!-- default --> <fo:conditional-page-master-reference master-reference="restliche"/> </fo:repeatable-page-master-alternatives> </fo:page-sequence-master> </fo:layout-master-set> <!-- Inhalt der verschiedenen Seiten --> <fo:page-sequence initial-page-number="1" master-reference="global"> <fo:static-content flow-name="first-before"> <fo:block> Hier ist der Titel der ersten Seite </fo:block> </fo:static-content> <fo:static-content flow-name="rest-before"> <fo:block> Der Titel der restlichen Seiten </fo:block> </fo:static-content> <fo:static-content flow-name="first-after"> <fo:block> Hier ist die Fusszeile der ersten Seite </fo:block> </fo:static-content> <fo:static-content flow-name="rest-after"> <fo:block> Hier ist die Fusszeile der restlichen Seiten </fo:block> </fo:static-content> <fo:flow flow-name="xsl-region-body">... hier kommt der Dokument Inhalt... </fo:flow> </fo:page-sequence> </fo:root> 98

39 Der Dokument Inhalt: fo:flow fo:flow ist ein Kind-Knoten von fo:page-sequence und enthält eine beliebige Anzahl von Blöcken mit Text, Tabellen, Listen und Bildern. Mit Hilfe des flow Elementes wird der Dokument-Inhalt (der Fliesstext) definiert. fo:flow hat als mögliche Kind-Elemente: fo:block (neuer Abschnitt) block-container (neuer Abschnitt an fixem Ort) table, table-and-caption (Tabelle) list-block (Listen) Ein Beispiel <fo:flow flow-name="xsl-region-body"> <fo:block font-size="16pt"> This is the document content. This is the <fo:external-graphic src="cup.gif"/> document content. This is the... </fo:block> </fo:flow> Die statischen Bereiche: fo:static-content In den Randbereichen befindet sich normalerweise wiederkehrende Information (Überschriften, Fussnoten, Seitenzahlen,...) <fo:static-content flow-name="xsl-region-after"> <fo:block text-align="end" font-size="10pt"> Seite <fo:page-number/> </fo:block> </fo:static-content> Abschnitte, Paragraphen,... fo:block fo:block erzeugt einen Bereich (ein oder mehrere Zeilen lang. fo:block wird benutzt, um zusammengehörende Ausgabe-Elemente (ein Textabschnitt, eine Titelzeile, eine Tabelle,...) zu gruppieren. <fo:block font-size="36pt"> Chapter 1: Introduction </fo:block> 99