Erstellung von druckbaren PDF-Dokumenten Ausrichtung von

Transcription

Fachhochschule Köln
University of Applied Sciences Cologne
Abteilung Gummersbach
Fachbereich Informatik
Diplomarbeit
zur Erlangung des akademischen Grades
Diplom-Informatiker (FH)
Erstellung von druckbaren PDF-Dokumenten
Ausrichtung von hebräischen
Schriftzeichenbildern
vorgelegt am:
von cand.:
aus:
4. Dezember 2003
Kirill Poletajew
Zschopaustr. 15
51371 Leverkusen
E-Mail-Adresse: kirill_pol@web.de
Matr.-Nr.:
11019707
Erstprüfer:
Zweitprüfer:
Prof. Dr. Heiner Klocke
Dr. Ittai Joseph Tamari
Vorwort
Vorwort
Diese Diplomarbeit wurde im Rahmen eines Forschungsprojekts „Hebräische
Typographie im deutschsprachigen Raum" entwickelt. Dieses Projekt stellt einen
webbasierten Schriftatlas dar. Die Aufgabe der Diplomarbeit war die Implementierung
von Methoden in das Projekt, die eine Erstellung von den druckbaren PDF-Dokumenten
ermöglichen. In dem Forschungsprojekt wurde „Model-View-Controller“ Architektur
eingesetzt. Alle Informationen werden in den XML-Bäumen gespeichert. Die
Darstellung von den Informationen erfolgt durch den Einsatz von XSL. Die
Informationen für die PDF-Dokumente werden ebenfalls aus den XML-Bäumen
ausgelesen. XSL-FO wird für die Gestaltung von den PDF-Dokumenten eingesetzt. Für
jedes PDF-Dokument wird eigenes Layout erstellt. Für die Transformierung von den
Informationen in PDF-Dokument kommen die Methoden von FOP zum Einsatz.
Die
auszudruckende
Dokumente
können
Informationen,
Schriftsätze,
Schriftzeichenbilder, Buchseiten, Illustrationen, Schmuckstücke beinhalten. Dabei wird
ein großer Wert auf die Darstellung von den Schriftzeichenbildern gelegt. Die
Schriftzeichenbilder wurden früher mit einem externen Programm einzeln erstellt und
als GIF-Bilder gespeichert. Beim Erstellen von den Schriftzeichenbildern wurden die
Buchstabenabbildungen einfach auf eine bestimmte Größe gebracht. In Folge dessen
wurden die Schriftzeichenbilder verzerrt gespeichert. So wurde die Aufgabe der
Diplomarbeit auf die zweite Aufgabe erweitert. Die Aufgabe bestand darin, ein
Programm speziell zu entwickeln, um die Schriftzeichenbilder auszurichten. Nach dem
Ausrichten bekamen alle Schriftzeichenbilder eines Schriftsatzes richtige Proportionen.
Im
Laufe
der
Entwicklung
des
Ausrichtungsprogramms,
wurde
auch
das
Vermessungsprogramm modifiziert. Das Vermessungsprogramm wurde fürs Ermitteln
von den realen Buchstabengrößen erstellt. Nach der Modifikation wurden auch die GIFBilder in diesem Programm erstellt. Der Schritt für die manuelle Erstellung von den
Schriftzeichenbildern ist überflüssig geworden.
Die vorliegende Arbeit erfuhr von vielen Seiten auf verschiedenste Art und Weise
Unterstützung. Nach der Fertigstellung meiner Diplomarbeit bedeutet es für mich mehr
als reine Höflichkeit, in diesem Vorwort all jenen Personen Dank zu sagen, die mir bei
Vorwort
der Arbeit geholfen haben. Zuallererst danke ich Prof. Dr. Heiner Klocke und Dr. Ittai
Joseph Tamari für die Betreuung der Arbeit, für ihre Diskussionsbereitschaft sowie auch
für wertvolle Tipps. Mein Dank gilt auch Dipl.-Inform. Uwe Poborski für sehr gute
Zusammenarbeit.
Zu Dank verpflichtet bin ich Dipl.-Inform. Juri Bauer, Nikos Choudetsanakis, Alexander
Fischer, Sergej Grünwald, Alex Maier, Alexander Peters, Oleg Tkachenko ohne deren
Hilfe und Unterstützung diese Arbeit wohl kaum gelungen wäre.
Kirill Poletajew
Gummersbach, im Dezember 2003
Inhaltsverzeichnis
Inhaltsverzeichnis
Vorwort
Abbildungsverzeichnis
iv
Tabellenverzeichnis
vi
1
Erstellung von druckbaren PDF Dokumenten
1
Einleitung / Problemstellung und Vorgehensweise
1
1.1.1
Einleitung
1
1.1.2
Problembeschreibung
2
1.1.2
Vorgehensweise
4
PDF Erzeuger und FO Standard
6
1.1
1.2
Etymon PJ:
6
iText:
6
XRenderer/ XEP Rendering Engine:
7
FOP: (Formatting Objects Processor)
8
Grundlagen der XML(eXtensible Stylesheet Language)
9
Grundlagen von Formatting Objekt:
1.3
11
FOP (Formatting Objects Printing)
24
1.3.1
Beschreibung von FOP
24
1.3.2
Installation von FOP
29
1.3.3
FOP Konfiguration
30
1.3.4
Derzeitig von FOP unterstützte Formate des XSL-FO Standards
33
Erstellen von PDF Dokumenten mit Hilfe von FOP
34
1.4.1
Festlegen des Layouts
34
1.4.2
Erstellen XSL-FO Dokumenten
60
1.4.3
Implementierung FOP Methoden in das Projekt
82
1.4
i
Inhaltsverzeichnis
1.5
Erste Ergebnisse und Erkenntnisse
87
1.6
Hebräische Zeichen in PDF
89
1.6.1
Problembeschreibung(bei „Right to Left“ Sprachen)
89
1.6.2
Suche nach möglichen Lösungen
89
1.6.3
Lösung
92
1.7
Ungelöste Probleme
92
1.8
Letzte Änderungen
93
Ausrichtung von hebräischen Schriftzeichenbildern
94
94
2.1.1
Einleitung
94
2.1.2
Problemstellung
96
2.1.2
Vorgehensweise
96
Grundlagen des hebräischen Schriftsatzes
98
2.2.1
Merkmale der hebräischen Schriftsätze
98
2.2.2
Merkmale von hebräischen Zeichen
99
2
2.1
2.2
2.3
Grundlagen der Bildbearbeitung in JAVA
103
2.3.1
Ein genereller Überblick der AWT und SWING Klassen
103
2.3.2
JIMI
105
2.3.3
JAI
106
2.3.4
GIFEncoder
108
Entwicklung des halbautomatischen Ausrichtungsverfahrens
111
2.5.1
Lösungsweg
111
2.5.2
Entwicklung des Ausrichtungsprogramms
114
2.5.1
Auftretende Probleme
125
2.5.2
Problemfindung- Untersuchung von Basisdaten.
126
2.5
ii
Inhaltsverzeichnis
2.6
Ablehnung den alten Algorithmus und Ideen für einen neuen Ansatz 128
2.7
Entwicklung des automatischen Ausrichtungsverfahrens
129
2.7.1
Lösungsweg
129
2.7.2
Ändern des Vermessungsprogramms
131
2.7.3
Entwicklung des Ausrichtungsprogramms
136
2.7.4
Auftretende Probleme
147
2.8
Einbau von Methoden für manuelle Korrigierung
147
2.9
Fertigstellung des Programms
148
Resümee: Ergebnisse und Erkenntnisse der Diplomarbeit
149
3
Glossar (Abkürzungen und Begriffserklärungen). Alphabetisch
151
Literaturverzeichnis
157
Anhang
159
Von FOP unterstützte Formate
159
Source Code
169
Inhalt der CD
170
iii
Abbildung 1
Die Model-View-Controller-Architektur des HebrewTypeShow und
Schnittstelle zu Web-Browsern..................................................................................4
Abbildung 2 Ablauf zur Erstellung von Formaten aus XML-Daten................................12
Abbildung 3 Seitenaufbau................................................................................................14
Abbildung 4 Fließobjekte.................................................................................................16
Abbildung 5 Seitenaufbau................................................................................................34
Abbildung 6 Layout Querformat......................................................................................35
Abbildung 7 Layout Hochformat .....................................................................................36
Abbildung 8 Logo ............................................................................................................36
Abbildung 9 Typografie-Vergleich HTML-Sicht ............................................................38
Abbildung 10 Typografie-Vergleich PDF-Sicht Seitentyp 1...........................................39
Abbildung 11 Typografie-Vergleich PDF-Sicht Seitentyp 2...........................................40
Abbildung 12 Schriftsatz-Detail HTML ..........................................................................43
Abbildung 13 Schriftsatzdetail Seitentyp 1......................................................................44
Abbildung 14 Schriftsatzdetail Seitentyp 2......................................................................45
Abbildung 15 Buchstabe-Detail HTML...........................................................................48
Abbildung 16 Buchstabe-Detailsicht Seitentyp 1 ............................................................49
Abbildung 17 Buchstabe-Detailsicht Seitentyp 2 ............................................................50
Abbildung 18 Bibliografie-Detailsicht HTML ................................................................52
Abbildung 19 Bibliografie-Detailsicht Seitentyp 1..........................................................53
Abbildung 20 Bibliografie-Detailsicht Seitentyp 2..........................................................54
Abbildung 21 Buchseite HTML.......................................................................................56
Abbildung 22 Buchseite ...................................................................................................57
iv
Abbildung 23 Schmuck-Detailsicht .................................................................................59
Abbildung 24 Die Model-View-Controller Architektur (am Beispiel von Typografie
Detailsicht) ...............................................................................................................83
Abbildung 25 Erste Ergebnisse (Typografie Vergleich)..................................................88
Abbildung 26 Neues Logo ...............................................................................................93
Abbildung 27 Positionierung ...........................................................................................94
Abbildung 28 Buchstabenmasse ......................................................................................95
Abbildung 29 Schriftzeichenbild(GIF) ............................................................................97
Abbildung 30 Addition ..................................................................................................108
Abbildung 31 Auswahl der Ober- und Unterlänge ........................................................111
Abbildung 32 Ausschneiden ..........................................................................................119
Abbildung 33 das Bild vor und nach der Verarbeitung .................................................120
Abbildung 34 das erste Schriftsatzausrichtungsprogramm............................................124
Abbildung 35 Halbkursive Schriftsatz nach der Ausrichtung .......................................125
Abbildung 36 Quadrate Schriftsatz nach der Ausrichtung ............................................125
Abbildung 37 Vermessungsprogramm ..........................................................................132
Abbildung 38 neue Version des Vermessungsprograms ...............................................133
Abbildung 39 Auswahlbox ............................................................................................136
Abbildung 40 Filestruktur ..............................................................................................137
Abbildung 41 nicht skalierte GIF-Bilder .......................................................................144
Abbildung 42 neue Ausrichtungs programm .................................................................146
Abbildung 43 Lamed .....................................................................................................147
v
Tabellenverzeichnis
Tabellenverzeichnis
Tabelle 1 Übersicht über alle Knoten und Ihre Inhalte ....................................................30
Tabelle 2 Beispiel dynamische Zeichenplatzierung in einer Tabelle...............................71
Tabelle 4 die hebräischen Buchstaben ...........................................................................102
Tabelle 5 Falsche Messdaten (ein Schriftzatz)...............................................................127
Tabelle 6 Tabelle 2 Derzeitig von FOP unterstützte Fomate des XSL-FO Standards ...168
vi
1
1.1
1.1.1 Einleitung
Die Erstellung von druckbaren PDF Dokumenten wurde als Teil des gesamten
Forschungsprojekts „Hebräische Typographie im deutschsprachigen Raum“ entwickelt.
Dieses Projekt ist von der Deutschen Forschungsgemeinschaft (DFG) gefördert worden.
„Ziel dieser Forschung ist die systematische Beschreibung der hebräischen Typographie
als interkulturelles Phänomen anhand hebräischer Druckerzeugnisse, die im deutschsprachigen Raum von 1500 bis 1939 hergestellt wurden.“1
Ziel dieses Forschungsprojekts ist die „Erstellung einer interaktiven, übers Internet zugänglichen Datenbank, welche hebräische Schriftsätze erfasst, systematisch und graphisch darstellt, Vergleiche und Suchergebnisse ausdrucken lässt (digitaler Schriftatlas).
Darüber hinaus soll eine Klassifikation des aschkenasischen Letternstils aufgrund der in
der Datenbank archivierten Schriftsätze vorgenommen werden“ [Zitat von Dr. Ittai
Joseph Tamari].
Das Projektteam besteht aus: Dr. Ittai Joseph Tamari (Projektleitung), Prof. Dr. Heiner
Klocke (Federführung u. techn. Leitung), Dipl.-Inform. Uwe Poborski (Softwarearchitektur), Prof. Dr. Koppitz (wissenschaftliche Begleitung), Nikos Choudetsanakis (digitale Fotografie u. Bildbearbeitung), Juri Bauer, Alex Maier und Alexander Peters (studentische Hilfskräfte), Kirill Poletajew(Diplomarbeit).
Die vollständigen Informationen über das Forschungsprojekt stehen auf der ProjektWebseite: http://www.gm.fh-koeln.de/hebrewtype zur Verfügung.
1
http://www.gm.fh-koeln.de/hebrewtype/deutsch/d_projektziel.html
1
1.1.2 Problembeschreibung
Mit dem Internet begann das „Informationszeitalter“.
Die Informationen aus dem Internet unterstützten uns in vielen Bereichen der Wissenschaft und Wirtschaft. In manchen Bereichen ersetzen die Informationen aus dem Web
teilweise die herkömmlichen Medien, wie zum Beispiel Zeitschriften und Magazine.
Die Internetseiten werden zunehmend qualitativer und die Brauchbarkeit der Inhalte und
Komplexität der Seiten ständig wachsen.
Die Menschen, als Benutzer des World Wide Webs, brauchen nur die gewünschten
Informationen zu finden.
In manchen Fällen reicht es aber nicht mehr aus, die gefundenen Informationen auf dem
Bildschirm zu sehen, sondern diese Informationen auch in einer gedruckten Form vor
sich liegen zu haben.
Für die Besucher einer Internetseite ist es oft nicht leicht herauszufinden, wie und in
welcher Form sie die Onlineinformationen ausdrucken können. Dies hat mehrere
Gründe:
1.
Verschiedene Browser bieten unterschiedliche Steuermöglichkeiten für das
Ausdrucken von Onlinedokumenten. Darunter versteht man Format der Dokumente(Hoch oder Querformat), Skalierungsmöglichkeit, Anpassen der Dokumente auf das Blatt usw.
2.
Verschiedene Web-Seiten haben viele Elemente, die dem Benutzer helfen
sich im Web zurechtzufinden, die verschiedene dekorative Elemente oder
Werbungsbanner. In einer druckbaren Form wollen die Wissenschaftler und
Interessierte dagegen eine „kompakte“ und „informative“ Version der Webseite haben.
3.
Das Ausdrucken von Informationen soll den Benutzer nicht zusätzlich belasten und von seiner Arbeit ablenken, sondern so einfach wie möglich und
präzise gestalten.
2
Die Aufgabe der Entwickler ist, die Informationen nicht nur im Browser qualitativ und
brauchbar darzustellen, sondern dem Benutzer die Möglichkeit geben, diese Informationen korrekt und bequem auszudrucken.
Vor Allem für dieses Projekt „Hebräische Typographie im deutschsprachigen Raum“ ist
die Möglichkeit die Informationen in einer korrekten und bequemen Form auszudrucken
ganz wichtig.
Die Menschen, die mit dem Projekt später weiter arbeiten, befassen sich mit den alten
Schriftsätzen, wobei die Darstellung und die Merkmalle des Schriftsatzes oder einzelnen
Buchstabens ganz wichtig sind. Die verzerrte Darstellung der Schriftsätze oder
Buchstaben kommt gar nicht in Frage.
Darüber hinaus, soll es ein Instrument gefunden werden, das erlaubt, die Informationen
in einer korrekten und bequemen Form auszudrucken, und den Benutzer von seiner
Arbeit nicht abzulenken.
Eines von diesen Instrumenten heißt PDF(Portable Document Format)
PDF ist per Definition ein statisches Datenformat. Alle Text-, Grafik- und Bild-Objekte
werden präzise in einem bestimmten Seitenformat gespeichert. Das heißt, dass die Informationen genauso angezeigt werden wie die in PDF platziert wurden. Die herausgegebene Information ist absolut unabhängig davon, welche Schriften bei dem Benutzer
installiert sind, was der Browser nicht gewährleistet.
Außerdem ist PDF ein Dokument, dass man entweder sofort ausdrucken oder für den
späteren Datenaustausch speichern kann. Speichern von Webseiten dagegen ist
Browserabhängig und hängt von den Einstellungen im Browser. ab
Die Voraussetzung für die Darstellung der PDF ist „Acrobat Reader“. Acrobat Reader
ist kostenlos erhältlich unter www.adobe.de
3
1.1.2 Vorgehensweise
Die PDF Dokumente werden aus den in XML- Bäumen vorhandenen Informationen erzeugt.
In der Projektdatenbank wurde „Model- View- Controller- Architektur“ benutzt
(Abbildung.1).
User Interface
Controller
Typografie Übersicht
SchriftsaetzeUebersichtSteuer
View
SchriftsaetzeUebersichtTransformer
XSL
Model
SchriftsaetzeUebersichtSicht
SchriftsaetzeUebersichtModell
XML
Typografie Deteilsicht
SchriftsatzDetailSteuer
SchriftsatzDetailTransformer
XSL
SchriftsatzDetailSicht
SchriftsatzDetailModell
SchriftsaetzeVergleichSicht
SchriftsaetzeVergleichModell
XML
Typografie Vergleich
SchriftsaetzeVergleichSteuer
SchriftsaetzeVergleichTransformer
XSL
XML
Bibliografie Übersicht
Bibliografie Deteilsicht
DruckTypeDetailSicht
DruckTypeDetailModell
HistorieSicht
HistorieModell
BuecherUebersichtSicht
BuecherUebersichtModell
XML
Dispatscher
Typografie Historie
DruckTypeDetailTransformer
HebrewShowServlet
Buchstabe-Detailsicht
XSL
HistorieTransformer
XSL
XML
BuecherUebersichtSteuer
BuecherUebersichtTransformer
BuchDetailSteuer
BuchDetailTransformer
XSL
XML
XSL
BuchDetailSicht
BuchDetailModell
SeiteDetailSicht
SeiteDetailModell
SchmuckDetailSicht
SchmuckDetailModell
IllustrationDetailSicht
IllustrationDetailModell
XML
Buchseite-Detailsicht
SeiteDetailTransformer
XSL
XML
Schmuck-Detailsicht
SchmuckDetailTransformer
XSL
XML
Illustration-Detailsicht
IllustrationDetailTransformer
XSL
XML
Web-Browser
Web-Server
via Internet
Abbildung 1
die Model-View-Controller-Architektur der HebrewTypeShow und Schnittstelle zu
Web-Browsern
Die Idee der „Model-View-Controller-Architektur“ ist- die Software nach systemfunktionalen Einheiten in die Komponenten: Model, View und Controller zu gliedern.
Model- Komponenten sind die Daten aus der Datenbank, die als Objekte geladen sind.
Die View- Komponenten beschreiben die Benutzungsschnittstelle mit Hilfe der Sprache
XSL(Extensible Stylesheet Language). Für jede Internetseite, die im Web- Browser dargestellt wird, gibt es eine XSL- Beschreibung.
Die Controller-Komponenten implementieren als Java-Servlet die dem Benutzer zur
Verfügung stehenden Funktionen. Dies sind die interaktiven Abläufe und Funktionen,
die dem Anwender an der Benutzungsschnittstelle zur Verfügung stehen. Benötigt ein
4
aktivierter Controller Informationen aus der Datenbank, so nimmt er die geladene Objekte aus dem zugehörigen Model. [HTiDR]
Die Gliederung der Software in drei Schichten, Modell, View und Controller hat
folgende Vorteile:
•
Das Layout der HebrewTypeShow- Benutzungsschnittstelle kann verändert werden, ohne dass die Funktionslogik davon betroffen wird. Realisiert wird dies
durch die Verwendung der Sprache XSL, durch die das graphische Layout beschrieben wird.
•
Die Funktionslogik kann verändert werden, ohne dass die Benutzungsschnittstelle und die Zugriffe auf die Datenbank davon berührt werden. Realisiert wird
das durch klare Trennung zwischen Model und Controller.
•
Das Model kann verändert werden, ohne dass die Benutzungsschnittstelle und
Funktionslogik davon betroffen werden. Dadurch ist der Einsatz von den anderen
relationalen Datenbanken möglich.
Beim Erstellen von PDF Dokumenten wird die gleiche Struktur verwendet.
Die Model- Komponenten sind schon vorhanden, das sind aus der Datenbank geladene
Objekte.
Die View- Komponenten beschreiben das PDF Layout mit Hilfe der Sprache XSLFO(Extensible Stylesheet Language – Formattik Object).
Die Controller-Komponenten implementieren Java Funktionen, die XML und XSL-FO
transformieren und als Ergebnis ein PDF Dokument liefern.
Es muss also ein Produkt geben, was die Transformation zwischen XML und XSL-FO
auch unterstützt. Da die XML Bäume automatisch mit Hilfe von, im Projekt integrierten,
Java Methoden generiert werden, muss das gesuchte Produkt in Java implementierbar
sein.
Und zuletzt in XSL-Dateien einen zusätzlichen Link einfügen, der die Methoden zum
Erzeugen der PDF Dokumente aufruft.
5
Kurze Zusammenfassung für Erstellen von PDF Dokumenten:
•
Zuerst eine XSL- FO Datei für jede auszudruckende Seite schreiben, die das
Layout dieser Seite beschreiben wird.
•
Zweitens,
in
das
Projekt
ein
Produkt
implementieren,
welches
die
Transformation zwischen XSL-FO und XML-Bäumen in PDF über seine
Methoden unterstützt.
•
Drittens, ein Button bzw. Link auf der entsprechenden Seite platzieren, um ein
PDF Dokument zu erzeugen.
1.2 PDF Erzeuger und FO Standard
Heutzutage gibt es viele Produkte auf dem Markt, die erlauben ein PDF Dokument „on
the fly“ zu erzeugen.
Hier werden einige davon analysiert:
Etymon PJ:
Dieses Java-Package ist Open Source und wird nach GNU General Public License
vertrieben.
Es ist eine Java Bibliothek, die Möglichkeit bietet, ein neues PDF-Dokument aus
vorhandenen Dokumenten (z.B. HTML) zu erzeugen, vorhandene PDF-Dokumente als
Vorlage zu öffnen und zu erweitern. Leider, um mit diesem Tool zu arbeiten, wird ein
tiefer Einblick in den Aufbau von PDF-Dokumenten benötigt.
Für unser Projekt ist Etymon nicht geeignet, da es keine XML/XSL Unterstützung bietet.[EPJOS]
iText:
iText ist eine freiverfügbare Java-Bibliothek von Bruno Lowagie und Paulo Soares.
Dieses Java Bibliothek wird nach zwei Lizenzen vertrieben. Erstmal nach Mozila Public
License (MPL) und LGPL(Lesser General Public License)
6
Mit Hilfe von iText Klassen werden Dokumente erzeugt, die plattformunabhängig sind,
Text, Listen, Tabellen und Bilder beinhalten.
iText Klassen sind sehr gut geeignet für die Leute die ein PDF-Dokument produzieren
wollen.
Diese Bibliothek ist besonders in der Kombination mit einem Servlet einsetzbar, was auf
Java Technologie basiert. Mit iText und PDF ist möglich, die Gestaltung des Dokuments
festzulegen.
iText braucht ein JDK 1.2. iText ist kostenlos unter einer vielfachen Lizenz MPL und
LGPL vorhanden:
iText ist sehr leicht zu erlernen, unterstützt UTF-8 Kodierung, arbeitet mit XML.
Beim Transformieren von XML Dateien werden die Informationen zur Gestaltung aus
dem DTD(Document Type Definition) gelesen.
<tag
name="paragraph"
alias="SPEAKER"
content="Speaker:">
<attribute
name="leading"
value="16"
/>
<attribute
name="size"
value="10"
/>
<attribute
name="style"
value="bold"
/>
</tag>
Es bietet also eine eingeschränkte Möglichkeit zur Gestaltung von XML Inhalten.
XSL-FO wird von iText gar nicht unterstützt.
Deshalb ist auch dieses Produkt für das Projekt „Hebräische Typographie im deutschsprachigen Raum“ nicht geeignet. [ITEXT]
XRenderer/ XEP Rendering Engine:
RenderX ist die erste Firma, die ein kommerzielles Produkt zur Generierung von PDF
Dokumenten mit Hilfe von XSL-FO entwickelte.
XEP Rendering Engine konvertiert XML Dokumente in ein druckfähiges Format (PDF
oder PostScript). Die XSL-FO wird für die Darstellung eingesetzt.
XEP Rendering Engine wurde in Java geschrieben, und läuft auf jedem System, dass
Java 2 (JDK/JRE 1.2.1) und höher unterstützt. Bessere Leistung wird mit JDK/JRE 1.3
oder höher erreicht.
7
XEP passt sich der folgenden Version von XSL an: W3C-Empfehlung vom 15. Oktober
20011. Es kann Eingang von einer Datei, einem Byte-Strom, oder einem grammatisch
analysierten XML-Dokument (über den Standard SAX oder Schnittstellen von DOM)
nehmen.
XEP Rendering Engine ist ein purer Java-Konverter, der die XSL-Dokumenten in das
PDF bzw. PostScript Format transformiert.
RenderX / XEP Rendering Engine ist ein kommerzielles Produkt, was die
Einsatzmöglichkeit dieses Produktes stark beschränkt.
Beim Integrieren dieses Produktes in das Projekt wird der Vorteil von
„Model-View-Controller“ Architektur verloren, da man an die Funktionslogik von
diesem kommerziellen Produkt gebunden ist.
Für unser Projekt ist auch nicht geeignet. [XRXEP]
FOP: (Formatting Objects Processor)
FOP gehört zu dem Apache's XML Projekt und ist weltweit der Erste 'print formatter'
für XSL formatierte Objekte. Es ist eine Java Anwendung, die einen XSL-FO Baum liest
und die resultierenden Seiten zu einer angegebenen Produktion macht. Zurzeit unterstützt FOP folgende Formate: PDF, PCL, PS, SVG, XML (Darstellung von
Baumstruktur), AWT (AWT viewer zeigt Fenster mit Java Grafiken in den Seiten), MIF
und TXT. Die derzeitige Version 0.20.5 setzt noch nicht den gesamten XSL-FOStandard um, und es wird derzeit an einer kompletten Implementierung gearbeitet. Das
Programm transformiert XML und XSL-FO zu einer „*.FO“ Datei und nutzt diese als
Eingabe. Auf den Seiten der Apache Software Foundation ist das Programm als
Quellcode und in der kompilierten Version angeboten.
Vertrieben wird FOP nach eine eigener Lizenz http://xml.apache.org/fop/license.html.
Da dieses Produkt mit XSL-FO arbeitet, ist er optimal geeignet für das Projekt „Hebräische Typographie im deutschsprachigen Raum“.
1
http://www.w3.org/TR/2001/REC-xsl-20011015/
8
Einziger Nachteil, dass FOP noch in Entwicklungsphase ist und nicht den gesamten
XSL- FO- Standard unterstützt. [FOPAP]
Grundlagen der XML(eXtensible Stylesheet Language)
Die Entwicklung von XML begann im Jahre 1996 und war im wesentlichen von den
Erfahrungen mit SGML und HTML geprägt.
•
SGML hatte sich zwar prinzipiell bewährt, konnte sich aber kaum verbreiten.
Einer der Hauptgründe dafür war die hohe Komplexität und der Umfang der
Sprachkonstrukte von SGML. Viele Sprachkonstrukte von SGML wurden nur
sehr selten verwendet.
•
HTML ist sehr stark Verbreitet und hat große Akzeptanz bei den Entwicklern,
hat aber auch Nachteile, wie z.B. Vermischung von Struktur und Layout der
Dokumente oder keine Erweiterbarkeit.
Aus diesen Erfahrungen heraus wurde XML mit dem Ziel geschaffen, die besten Eigenschaften von SGML und HTML zu übernehmen:
•
Vereinfachung der Komplexität von SGML durch weglassen selten benutzten
Konstrukten.
•
Nutzung der Strukturiertheit und Erweiterbarkeit von SGML.
•
Nutzung der Akzeptanz und der Verbreitung von HTML.
Im Februar 1998 wurde die Entwicklung abgeschlossen und der XML- Standard Version
1.0 verabschiedet. Er ist unter http://www.w3.org/TR/REC-xml abrufbar.
XML- Tags beschreiben den Inhalt und nicht die Form, in der die Daten dargestellt werden. HTML zeigt Ihnen nur, wie Daten aussehen. XML zeigt dagegen, was die Daten
bedeuten. Wie sie aussehen sollen, bestimmen der Entwickler selbst. Das Look-and-Feel
eines XML- Dokuments wird über XSL Stylesheet festgelegt. Mit XSL können Dokumente (oder eine ganze Web Site) gestaltet werden, ohne dass der Inhalt des Dokuments
dabei angetastet würde. Damit lässt sich derselbe Inhalt ganz einfach auf verschiedene
Weise wiedergeben.
9
XML Unterstützt mehrsprachige Dokumente und Unicode. Diese Eigenschaft ist für die
Internationalisierung von Anwendungen von Bedeutung.
XML ist ein W3C-Standard und wird von führenden Unternehmen der Softwarebranche
unterstützt.
Art und Anzahl der Tags sind nicht begrenzt. Nach Bedarf können neue Tags hinzugefügt werden.
XML- Dokumente können jeden denkbaren Datentyp enthalten - von Multimediadaten
(Bilder, Sound, Videos) bis zu aktiven Komponenten (Java-Applets, ActiveX).
Bestehende Datenstrukturen wie Dateisysteme oder relationale Datenbanken lassen sich
einfach auf XML abbilden. XML unterstützt eine Vielzahl von Datenformaten und deckt
alle existierenden Datenstrukturen ab.
XML- Dokumente können aus geschachtelten Elementen zusammengesetzt sein, die auf
mehreren entfernten Servern liegen. Derzeit ist XML das ausgereifte Format für verteilte
Daten. Das World Wide Web kann sozusagen als eine riesige XML-Datenbank
betrachtet werden.
XML ist eine „Markup“- Sprache. Ein XML-Element besteht aus einem Anfangs-Tag,
End-Tag und den Daten dazwischen.. Die Daten innerhalb dieser Tags werden als Wert
des Elements bezeichnet.
<titel>Typografie-Detailsicht</titel>
Elementname <titel> erlaubt es, den Inhalt „Typografie-Detailsicht“ semantisch zu
markieren. So kann man die einzelnen Daten unterscheiden.
Ein XML Element kann auch mehrere XML Elemente enthalten.
<sprachen>
<one>english</one>
<two>deutsch</two>
</sprachen>
Am Anfang eines gültigen XML-Dokuments kann eine Angabe geben, mit der die
verwendete XML-Version genannt wird, aber diese Angabe ist nicht unbedingt nötig.
Wenn vorhanden, dann muss die Angabe diese Form haben:
<?xml version="1.0" encoding="UTF-8"?>
(Wobei 1.0 natürlich durch die jeweils zutreffende Angabe ersetzt werden muss).
10
Es gibt drei Grundsätze, die bei Erstellung eines XML Dokuments zu beachten sind:
•
Auf jeden Start-Tag muss ein Ende Tag folgen, da im Gegensatz zu HTML, wo
der Browser es mit einer überschaubaren Anzahl von Tags zutun hat, und ein
fehlendes Tag bei der nächsten Formatierungsänderung vom Browser
hininterpretiert werden könnte, ist dies bei XML nicht möglich. Der Grund dafür
ist die Verwendung semantischer und vorher nicht definierter Tags.
•
Alle Elemente müssen sauber ineinander verschachtelt sein (Überlappende
Elemente sind nicht zulässig).
<one>english
<two>deutsch</one></two>
•
Alle Attributwerte müssen mit Anführungszeichen angeführt werden. [XML10]
Grundlagen von Formatting Objekt:
Damit die Dokumente mit XML basierten Daten erstellt werden können, entwickelte das
World Wide Web Consortium (W3C) die XSL-Spezifikationen (Extensible Stylesheet
Language). Mit Hilfe von XSL-FO (Extensible Stylesheet Language Formatting Objects) können Entwickler spezifische Layouts und Stile für eine gedruckte Seite definieren und XML-Daten einfließen lassen.
Formatting Objects sind Bestandteile von XSL. Jeder Tag was mit „<fo:“ beginnt, ist ein
Formatting Object Tag.
Formatting Objects beschreiben die Formateigenschaften von Dokumentteilen und
Dokumentinhalten, wie Seiten, Absätze, Fußzeilen, Schriften, Grafiken, Tabellen, Listen
und vieles mehr.
XSL-FO deckt dabei die gesamte Bandbreite des Layouts ab - von Online-Dokumenten
bis hin zu gedruckten Handbüchern mit komplexer Seitengestaltung. Gerade dann,
wenn es um die Produktion hochwertiger Druckerzeugnisse geht, schließt XSL-FO hier
eine bislang gravierende Lücke.
11
PDF
XMLDokument
XSLTransformation
XSL-FODokument
Formatierer
PS
Abbildung 2 Ablauf zur Erstellung von Formaten aus XML-Daten
Ein XML- Dokument wird mit einem XSL-Stylesheet in ein XSL-FO Dokument umgewandelt. Diese XSL-FO Datei wird dann mit Hilfe eines Formatierungsprogramms
zum Beispiel in ein PDF-Dokument konvertiert.
XSL-FO basiert auf rechteckigen Bereichen. Diese Bereiche können leer sein, beinhalten Text, Bilder oder andere Objekte.
Der Aufbau eines XSL-FO Dokuments ist immer gleich. Zu Beginn werden die Seiten
definiert. Dabei werden die Größe, die Ränder und die beschreibbaren Regionen festgelegt. Darauf folgen optional Deklarationen, wie die Bestimmung eines einzusetzenden
Farbprofils. Im Anschluss folgt die Beschreibung des gesamten Inhalts und aller seinen
Eigenschaften, wie Position, Fonts und Farben. Der folgende Code zeigt den grundlegenden Aufbau eines XSL-FO Dokuments:
Aufbau eines FO Dokuments
<fo:root>
<fo:simple-page-master master-name="schriftsaetze"
page-height = "210mm"
margin-top = "10mm"
margin-left = "10mm"
page-width = "297mm"
margin-bottom = "10mm"
margin-right = "10mm">
<fo:region-body margin-top="40mm" margin-bottom="10mm"/>
<fo:region-before extent="40mm" />
<fo:region-after extent="10mm" />
</fo:simple-page-master>
<fo:page-sequence master-reference="schriftsaetze">
12
<fo:static-content flow-name="xsl-region-before">
…
</fo:static-content>
<fo:static-content flow-name="xsl-region-after">
…
<fo:flow flow-name="xsl-region-body">
<fo:block>
…
</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
XSL-FO Dokument ist in zwei Bereichen aufgeteilt:
•
Beschreibung der Seiten. Festlegung des Layouts für die zu füllende Seiten(<fo:layout-master-set>)
•
Belegung des Inhaltes der Seiten(<fo:page- sequence>)
Beschreibung der Seiten
Bei der Beschreibung des Seitenlayouts werden die Höhe, die Breite und die Abstände
von dem Seitenrand bestimmt. Jedes Seitenlayout ist durch eigenen Namen bezeichnet.
<fo:simple-page-master master-name="schriftsaetze"
page-height = "210mm"
page-width = "297mm"
margin-top = "10mm"
margin-bottom = "10mm"
margin-left = "10mm"
margin-right = "10mm">
Außerdem werden die einzelnen Regionen, wie Anfang des Hauptfeldes, Höhe der
Kopf- und Fußzeilen, definiert, damit die Inhalte der einzelnen Bereiche nicht
aufeinander platziert werden.
<fo:region-before extent="40mm" />
<fo:region-after extent="10mm" />
13
Abbildung 3 Seitenaufbau
Der Bereich „region-body“ stellt die eigentliche Schreibzone des Dokuments dar. Neben
ihm lassen sich aber noch vier weitere Regionen definieren. Nur in diesen Regionen
können Inhalte eingefügt werden. Die anderen Bereichen liegen über, unter, links und
rechts vom region-body. Diese Regionen eignen sich somit besonders für alle festen
Angaben, wie Kopf- oder Fußzeilen, Seitenzahlen oder Titel. In Abbildung 3 wird der
Aufbau einer Seite mit den Regionen dargestellt.
Belegung des Inhaltes der Seiten
Jeder XSL-FO Dokument hat eins oder mehrere Elemente „<fo:page-sequence>“. Innerhalb von diesem Knoten wird der Inhalt der Seite platziert. Jede „<fo:pagesequence>“hat
definiert.
ihre „<fo:simple-page-master>“, die das Aussehen von dieser Seite
Name
der
Master-Seite
reference="schriftsaetze"
wird
dabei
mit
dem
Attribut
„master-
“ festgelegt.
14
Der Inhalt der Seite wird innerhalb der Knoten „<fo:page-sequence masterreference="schriftsaetze">“ gefüllt.
Die einzelnen Regionen des Layouts, wie Kopfzeile, Fußzeile und Hauptteil, werden
auch separat behandelt. Inhalt der Kopf- und Fußzeile wird auf jeder kommenden Seite
abgebildet.
<fo:root>
…
<fo:page-sequence master-reference="schriftsaetze">
…
…
<fo:block>
…
</fo:block>
</fo:flow>
</fo:page-sequence>
</fo:root>
Der Hauptteil des Dokuments ist “<fo:flow flow-name="xsl-region-body">”. Dieser
Region beinhaltet Block-Level Elemente. Wenn der Inhalt nicht auf eine Seite passt, so
wird er automatisch auf die Seiten aufgeteilt.
15
Abbildung 4 Fließobjekte
Es gibt zwei Arten von Fliessobjekten:
•
Block-Level Elemente fließen von oben nach unten, das heißt, die stehen
untereinander.
•
Inline-Level Elemente fließen von rechts nach links oder umgekehrt innerhalb eines Blockes mit automatischem Umbruch.
Block-Level Elemente
Zu den Block-Level-Elementen gehören:
•
fo:block
•
fo:block-container
•
fo:table-and-caption
•
fo:table
•
fo:list-block
16
Block-Level Elementen sind rechteckige Bereiche, die voneinander mit Zeilenumbruch
oder anderen Formatierungselementen getrennt sind. Diese können andere Block-LevelElemente oder Inline-Level-Elemente beinhalten.
Das Element „<fo:block>“ ist Identisch dem HTML Tag „<DIV>“. Es ist ein
rechteckiger Bereich, der einfacher Text oder anderen Block-Level Elemente beinhalten
kann. Außerdem kann das Element „<fo:block>“ auch Inline-Level Elemente
beinhalten, wie z.B. „<fo:page-number>“.
<fo:block text-align="left">
Hallo!!!
<fo:page-number />
</fo:block>
Die Block Elementen haben Attribute, die Eigenschaften des Bereiches und die Texteigenschaften beschreiben. Die Texteigenschaften eines Block-Elements werden als
Vorgabe von allen Kinderknoten übernommen.
Tabelle
Das Element „<fo:table>“ ist ein Blockelement, aber die Einzelelemente der
„<fo:table>“ sind weder Block-Level Elemente noch Inline-Level Elemente. Es gibt
neun Formatierungsobjekte für die Tabelle:
•
fo:table-and-caption
•
fo:table
•
fo:table-caption
•
fo:table-column
•
fo:table-header
•
fo:table-footer
•
fo:table-body
•
fo:table-row
•
fo:table-cell
17
Ein Hauptelement einer Tabelle kann entweder „<fo:table>“ oder „<fo:table-andcaption>“, der „<fo:table>“ und „<fo:table-caption>“ beinhaltet, sein. Das Element
„<fo:table>“ hat folgende Kinderknoten: „<fo:table-column>“, „<fo:table-header>“,
„<fo:table-footer>“ und „<fo:table-body>“. Mit dem Element „<fo:table-column>“ bestimmt man die Breite der einzelnen Spalte. Der Körper der Tabelle „<fo:table-body>“
beinhaltet Zeilen „<fo:table-row>“, die mit den Elementen „<fo:table-cell>“ in die
Spalten aufgeteilt werden.
<fo:table table-layout="fixed">
<fo:table-column column-width="10mm" />
<fo:table-column column-width="267mm" />
<fo:table-body>
<fo:table-row>
<fo:table-cell>
<fo:page-number />
</fo:block>
</fo:table-cell>
<fo:table-cell>
<fo:block font-family="Arial" font-size="10pt"
font-weight="bold" text-align="right">
<fo:bidi-override unicode-bidi="normal" direction="rtl">
<xsl:apply-templates select="Name" />
</fo:bidi-override>
</fo:block>
</fo:table-cell>
</fo:table-row>
</fo:table-body>
</fo:table>
Es gibt auch die Möglichkeit, die einzelnen Zellen oder Spalten zu verbinden.
Vorausgesetzt man verwendet die Attribute „number-columns-spanned“ oder „numberrows-spanned“. Als Wert für diese Attribute wird angegeben, wie viele Zellen oder
Spalten man verbinden möchte. Mit dem Attribut „column-number“ wird die Stelle
eingegeben ab deren die Verbindung anfangen soll, ist dieses Attribut nicht gesetzt, so
wird die aktuelle Spalte genommen.
Das Element „<fo:table-column>“ ist für die Eigenschaften der gesamten Spalte verantwortlich. Spalten für die dieses Element zuständig ist werden durch die Position des Elements oder mit dem Attribut „column-number“ festgelegt. In den meisten Fällen wird in
18
diesem Element das Attribut „column-width“ eingesetzt. Mittels dieses Attributes wird
die Spaltenbreite angegeben. Außerdem kann man unter diesem Element die Attribute,
für Fonts, freies Raum zwischen der Grenze der Zelle und dem Inhalt, einsetzen.
Inline-Level Elemente
Zu den Inline-Level Elementen gehören:
•
fo:inline
•
fo:inline-container
•
fo:page-number
•
fo:bidi-override
•
fo:external-graphic
•
…
Die Inline-Level Elementen sind rechteckige Bereiche. Die beinhalten Text oder andere
Inline-Level Elemente. Meistens werden Inline-Level Elemente mit dem Text gefüllt.
Der Textfluss wird von der Schreibweise bestimmt. Zum Beispiel wenn Hebräisch oder
Arabisch geschrieben wird, soll der Textfluss von rechts nach links fließen. Wenn der
Bereich gefüllt ist, wird automatisch ein Zeilenumbruch erzeugt und eine neue Zeile
angefangen.
Graphik
Im XSL-FO gibt es zwei Möglichkeiten eine Graphik in ein Dokument einzufügen. Das
Element „<fo:external-graphic>“ fügt eine nicht XML-Graphik in das Dokument ein.
Das Element „<fo:instream-foreign-object>“ fügt ein XML-Dokument, zum Beispiel
SVG, in das Dokument.
19
fo:external-graphic
Das Element „<fo:external-graphic>“ ist äquivalent dem HTML Tag „img“. Das heißt,
dass eine Graphik aus einer URL geladen wird. Der Tag „<fo:external-graphic>“
beinhaltet keine Kinderelemente. Im Attribut „src“ steht der URL (Pfad zu der
Graphikdatei).
<fo:external-graphic height="15mm" src="images/logo.gif" />
„<fo:external-graphic>“ ist ein Inline-Level Element. Man kann die Graphik auch als
ein Block darstellen. Dafür wird die Graphik in einen Block platziert.
<fo:external-graphic height="15mm" src="images/logo.gif" />
</fo:block>
fo:instream-foreign-obect
Das Element „<fo:instream-foreign-object>“ fügt ein graphisches Element, der im
XML geschrieben ist, direkt in das XSL-FO Quellkode ein. Das Element
„<fo:instream -foreign-object>“ beinhaltet SVG. Transformer gibt dann SVG als
Graphik im Dokument wieder.
<fo:instream-foreign-object>
<svg:svg width="100pt" height="100pt"
xmlns:svg="http://www.w3.org/2000/svg">
<svg:circle cx="50pt" cy="50pt" r="30pt" style="fill:blue;" />
</svg:svg>
</fo:instream-foreign-object>
Elemente „<fo:external-graphic>“ und „<fo:instream-foreign-object>“ haben Attribute für die Größe, Skalierung, und Ausrichtung.
Attribute „height“ und „width“ setzen vertikale und horizontale Größen des rechteckigen
Bereiches, in dem die Graphik platziert wird. Jedes Attribut kann den Wert „auto“
bekommen. Dann wird automatisch die Originalgröße des Images genommen.
Attributen „content-height“ und „content-width“ setzen die eigentliche Größe des
Images. Wenn die Werte nicht mit den Größen von „height“ und „width“
übereinstimmen, wird die Grafik entsprechend skaliert.
Das Attribut „scaling“ ist für Skalierung verantwortlich. Dieses Attribut kann „unifotm“
oder „non-uniform“ sein. Beim Setzen des Attributes auf „uniform“, wird die Graphik
20
proportional skaliert. Wenn es aber auf „non-uniform“ gesetzt wurde, dann wird die
Graphik einfach auf vorgegebene Größe skaliert und möglicherweise verzerrt.
Außerdem kann mit Hilfe des Attributes „scaling-method“ ein Algorithm für die
Skalierung ausgewählt werden. Dieses Attribut kann auf „auto“, „integer-pixels“ und
„resample-any-method“ gesetzt werden. Bei dem Wert „integer-pixels“ wird die Grafik
um einen ganzzahligen Wert skaliert (z.B. 2:1, 3:1 aber niemals 1,5:1). Beim Einsetzen
von dieser Methode, werden die Farbübergänge nich geglättert. Deshalb wird meisten
Fällen nach dieser Methode skalierte Grafik kleiner als bei dem Einsatz eines anderen
Algorithmus. Beim Wert „auto“ entscheidet der Formatter selbst welche Methode für
Skalieren eingesetzt wird.
Attribute von Formatting Object
Die Formatting Objects selbst beinhalten wenig Informationen über die Darstellung von
Informationen. Die bestimmen einfach den rechteckigen Bereich, wo die Information
positioniert werden soll. Information über stilistische Darstellung wird mit den Attributen von Formatting Objects bestimmt. Insgesamt gibt es über 200 verschiedene Attributen. Nicht alle von diesen Attributen können universell an alle Formatting Objects
eingewendet werden. Es macht zum Beispiel kein Sinn das Attribut „font-family“ an das
Element „fo:external-graphic“ anzuwenden. Nichtsdestoweniger können die meisten
Attribute auf mehreren Objekten angewendet werden. Viele von Attributen haben die
gleiche Bedeutung wie die CSS Attributen. Attribut von CSS „font-family“ stimmt mit
dem XSL-FO Attribut „font-family“ überein.
Hier werden nur die Attribute beschrieben, die für die Erstellung von XSL-FO, in
diesem Projekt relevant waren.
Schriftattributen
Jeder Formatting Object, der die Textinformation enthält, hat viele Möglichkeiten für die
Schriftdarstellung:
•
font-family bestimmt den Fontfamilie der Schrift
•
font-size bestimmt die Größe einer Schrift.
21
•
font-weight bestimmt die Dicke der Linien mit denen der Schrift gezeichnet
wird. Dieses Attribut kann folgende Werte haben: 100…900, „bold“, „bolder“,
„lighter“ oder „normal“
•
font-style bestimmt den Stil einer Schrift. Kann „italic“, „normal“, „oblique“,
„reverse-normal“, „reverse-oblique“ sein.
•
…
Hintergrundattributen
Es gibt in XSL-FO fünf Attributen für die Hintergrunddarstellung.
Das sind:
•
background-color bestimmt die Hintergrundfarbe. Als Eingabe wird die Farbe
#EEEEEE,
als Wort (z.B. „red“), oder Schlüsselwort „transparent“ eingegeben.
•
background-image URL für die Hintergrundsgraphik oder Schlüsselwort „none“.
•
background-attachment bestimmt die Hintergrundgraphik. Kann die Werte
„fixed“ oder „scroll“ haben.
•
background-position Hintergrundposition. Legt fest, wo die Hintergrundgraphik
positioniert wird. Die Werte sind: „center“, “left“, „bottom“, „top“, „middle“,
oder die Koordinaten.
•
background-repeat Bestimmt, ob die Hintergrundgraphik mehrmals in einem
Block dargestellt wird, vorausgesetzt die Grafik ist kleiner als Block. Hat die
Werte: „repeat“, „no-repeat“, „repeat-x“, „repeat-y“.
Absatzattributen
•
text-align Textausrichtung. Hat folgende Schlüssel: start= linksbündig, end=
rechtsbündig, center= zentriert, justify= Blocksatz.
•
start-indent linksseitige Einrückung des gesamten Absatzes. z.B. 2mm
•
text-indent Einzug für die erste Zeile des Absatzes
•
end-indent rechtsseitige Einrückung des gesamten Absatzes
22
•
space-before Freiraum vor dem Absatz
•
space-after Freiraum nach dem Absatz
Die Angabe von Bereichen ist auch möglich. Dazu können folgende Suffixe an den
Attributnamen angehängt werden
.optimum bevorzugter Wert
.minimum minimaler Wert
.maximum maximaler Wert
Attributen für die Randabstände
Es gibt insgesamt acht Attributen, die Abstände von Boxgrenze bis zu Inhalt regeln:
•
padding-left
•
padding-right
•
padding-top
•
padding-bottom
•
padding-before
•
padding-end
•
padding-start
•
padding-after
Zum Beispiel wird der Text in einem Abstand von 5 Millimeter von der linken
Blockgrenze anfangen.
<fo:block padding-left="5mm">
Hallo
</fo:block>
23
Attributen zum Mischen von Schreibrichtung
Das Element „<fo:bidi-override>“ dient zum mischen von Schreibrichtungen in Unicode. Dabei bestimmt das Attribut „direction“, wie die Textrichtung verlaufen soll. Dieser Attribut kann folgende Schlüssel haben: „rtl“, „ltr“, „inherit“. Das Attribut „unicodebidi“ bestimmt, wie Unicode behandelt wird.
Es gibt drei Werte für „unicode-bidi“:
•
„normal“ Das Element öffnet keine zusätzliche Einbettungsebene für den
Bidirektionalitätsalgorithmus. Für Elemente auf Inline-Ebene funktioniert die
implizite Neuanordnung über Elementgrenzen hinweg.
•
„embed“ Befindet sich das Element auf Inline-Ebene, öffnet dieser Wert eine zusätzliche Einbettungsebene für den Bidirektionalitätsalgorithmus. Die Richtung
dieser Einbettungsebene wird durch die „direction“-Eigenschaft vorgegeben. Innerhalb des Elements erfolgt die Neuanordnung implizit.
•
„bidi-override“ Es handelt es sich um ein Element auf einer Inline-Ebene oder
um ein Element auf einer Blockebene. Innerhalb des Elements erfolgt die
Neuanordnung streng in Folge nach der 'direction'-Eigenschaft. Der implizite
Teil des Bidirektionalitätsalgorithmus wird dabei ignoriert. [XSL10]
1.3 FOP (Formatting Objects Printing)
1.3.1 Beschreibung von FOP
Eins von mehreren Zielen des Apache-XML-FOP-Projektes ist, ein XSL-FO an einen
PDF Formatierer zu liefern. Dabei wurde PDF Standard von 11 März 1999 Portable
Document Format Specification (Version 1.3)1 realisiert. Auch die XML 1.0
Empfehlung2, XSLT 1.0 Empfehlung3 und XML Namespaces Empfehlung wird
1
http://partners.adobe.com/asn/acrobat/docs/File_Format_Specifications/PDFReference13.pdf
2
http://www.w3.org/TR/1998/REC-xml-19980210
3
http://www.w3.org/TR/xsl/
24
unterstützt. Das FOP Projekt versucht, die neueste Version der entwickelnden
Spezifikationen zu verwenden. Das FOP Layoutsystem wird zur Zeit neu geschrieben,
um Unterstützung der XSL-FO Standard zu verbessern.
Noch unterstützt FOP die Spezifikation des WWW-Konsortiums nicht vollständig. Auch
nicht alle Möglichkeiten von SVG können von FOP verarbeitet werden (Z.B.
Animationen, die in einem druckorientierten Format unsinnig sind). Dennoch können
inzwischen brauchbare PDF-Dokumente erzeugt werden.
Die letzte Version von FOP (0.20.5) unterstützt Formatierungs-Objekte von W3C
Empfehlung 15 Oktober 20011.
Möglichkeiten von FOP
FOP unterstützt nicht nur Mehrsprachigkeit, sondern auch die Silbertrennung. Dafür
werden die Silbentrennungsmuster für die jeweilige Sprache eingesetzt. In der letzten
Version von FOP sind die Silbentrennungsmuster für folgende Sprachen implementiert:
deutsch (de, de_DR), englisch (en, en_US), finnisch (fi), spanisch (es), ungarisch (hu),
italienisch (it), polnisch (pl), portugiesisch (pt), russisch (ru).
FOP bietet auch die Möglichkeit zusätzliche True Type Fonts einzubinden.
FOP unterstützt auch grafische Formate, wie GIF und JPEG. Mit Hilfe von externen
Bibliotheken (JIMI oder JAI) kann man auch andere grafische Formate einsetzen(PNG,
PSD, TIFF, BMP, …).
Es gibt zwei Möglichkeiten Dokumenten mit Hilfe von FOP zu erzeugen:
•
FOP als eine selbständige Anwendung starten und
•
Die FOP-Klassen in eine Java Anwendung einzubinden
FOP als eine selbständige Applikation zu starten.
In diesem Fall wird fop.bat(Windows) oder fop.sh(UNIX/Linux) von der Kommandozeile mit Parametern aufgerufen.
1
http://www.w3.org/TR/2001/REC-xsl-20011015
25
fop [options] [-fo|-xml] infile [-xsl file] [-awt|-pdf|-mif|-pcl|-ps|txt|-svg|-at|-print] <outfile>
[OPTIONS]
-d
debug Modus
-x
Anzeige Konfiguration Einstellung
-q
ruhiger Modus
-c cfg.xml
Benutzen von zusätzlichen Konfigurationsdatei cfg.xml
-l lang
die Sprache für die Navigation und Menü im AWT Fenster, oder für die Trennungsmuster
-s
angezeigt
(-at Ausgabe) Inhatl von Blockarea wird nicht
[INPUT]
infile
XSLFO zu transformierende Eingabedatei (entweder
eine fo Datei, oder XML und XSL Datei)
-fo
infile
-xml infile
verwendet.
-xsl stylesheet
xsl:fo Datei. Ist Defaultwert.
xml Datei, muss unbedingt zusammen mit
xsl Layout
xslt Layout
[OUTPUT]
outfile
-pdf outfile
-awt
angezeigt
Name für die Ausgabedatei.
Eingabe wird in eine pdf Datei transformiert
Eingabe wird in einem Fenster als AWT Grafik
-mif outfile
Eingabe wird in eine mif Datei transformiert
-pcl outfile
Eingabe wird in eine pcl Datei transformiert
-ps outfile
Eingabe wird in eine ps Datei transformiert
-txt outfile
Eingabe wird in eine Textdatei transformiert
-svg outfile
Eingabe wird in eine svg Grafik transformiert
-at outfile
Eingabe wird als ein XML Baum angezeigt
-print
Sendet die Ausgabe sofort nach Drucker
[Beispiele]
fop foo.fo foo.pdf
fop -fo foo.fo -pdf foo.pdf (ist das Gleiche wie erstes Beispiel)
fop -xsl foo.xsl -xml foo.xml -pdf foo.pdf
fop foo.fo -mif foo.mif
fop foo.fo -print oder fop -print foo.fo
fop foo.fo -awt
26
Die FOP-Klassen in eine Java Anwendung einzubinden
Sehr oft ist notwendig dynamisches Erstellen eines Dokumentes automatisch aus
irgendeiner Java Anwendung zu starten. Die komplette FOP-Anwendung mit den
Parametern zu starten ist nicht effizient. Viel besser und bequemmer ist die Möglichkeit,
nur notwendige FOP-Klassen in eine Java-Anwendung zu implementieren, die aus
einem FO-Datenstrom ein Dokument erstellen. Das Projekt „Hebräische Typographie im
deutschsprachigen Raum“ basiert auf einem Jva-Servlet. Die FOP-Klassen werden in
dieses Servlet implementiert.
Einbinden von FOP-Klassen
Transformieren von dem Informationsfluss in das entsprechende Ausgabeformat erfolgt
mittels der Klasse „org.apache.fop.apps.Driver“. Um diese Klasse zu instatiieren, muss
zuerst die notwendige FOP-Bibliothek instantiiert werden:
import org.apache.fop.apps.*;
Die einfachste Art ein Dokument zu erzeugen, ist es ein Objekt der Klasse Driver mit
den Parametern zu erstellen.
Im Beispiel enthält args[0 ] den Eingabestrom von einer XSL-FO Datei. Argument
args[1 ] enthält einen Pfad zu dem Zieldokument.
Driver driver = new Driver(new InputSource(args[0]),
new FileOutputStream(args[1]));
Format des Zieldokuments wird mit der Methode setRenderer(Driver.RENDER_PDF)
eingestellt.
Der Schlüssel Driver.RENDER_PDF ist für den Zielformat verantwortlich.
driver.setRenderer(Driver.RENDER_PDF);
Die Methode „run()“ startet die Transformation.
driver.run();
Eingabe und Ausgabestrom können auch getrennt eingegeben werden.
driver.setInputSource(new FileInputSource(args[0]));
driver.setOutputStream(new FileOutputStream(args[1]));
27
Verwenden einer externen Konfigurationsdatei.
In der Konfigurationsdatei werden die Pfade für erzeugte XSL-FO Dateien und Fonts
eingegeben.
FOP ist standartmässig mit 14 Fonts kompiliert. Das sind: Helvetica (normal, bold,
italic, bold italic), Times (normal, bold, italic, bold italic), Courier (normal, bold, italic,
bold italic), Symbol und Zapf Dingbats. Leider beinhalten diese Fonts keine Kyrillische
oder Hebräische Zeichen. Deshalb erscheinen nach dem Erzeugen des Dokumentes,
anstatt von richtigen Zeichen nur „#“ raus. Um es zu vermeiden müssen
benutzerdefinierte Unicode Fonts eingebunden werden. Die Pfade zu diesen Fonts
werden in der Konfigurationsdatei gesetzt.
Um eine externe Konfigurationsdatei einzubinden muss eine entsprechende Bibliothek
instantiiert werden.
Das neues Objekt der Klasse „Options“ wird erzeugt. Der Constructor der Klasse
bekommt als Eingabeparameter Pfad zu der Konfigurationsdatei.
import org.apache.fop.apps.Options;
/*
…
*/
userConfigFile = new File(userConfig);
Options options = new Options(userConfigFile);
28
1.3.2 Installation von FOP
Für die Installation von FOP braucht man folgende Software:
•
Java 1.2.x oder eine spätere Version
•
FOP. FOP-Distribution beinhaltet alle Bibliotheken, die man für Installation von
FOP braucht. Diese liegen in der „fop/lib“ Verzeichnis. Die Bibliotheken beinhalten:
o Apache Xerces für XML Syntaxanalyse. Xerces unterstützt SAX- und
DOM-Parser nach der SAX 1.0 bzw. DOM Level 1 Spezifikation. Man
kann auch andere XML-Parser benutzen, die SAX und DOM unterstützen. Xerces überprüft, ob ein Dokument wohlgeformt ist und dem DTD
entspricht.
o Apache Xalan. Es ist ein XSLT Prozessor. Xalan ist für die Transformation von XML und XSL Dateien zuständig.
o Apache Batik, ist eine SVG Bibliothek
Grundlegende FOP Installation
Zuerst wird die Datei „fop-0.x.x.tar.gz“ in ein Verzeichnis entpackt. Die Voraussetzung
für den FOP ist die JVM (Java Virtual Mashine). Die muss auf dem Rechner installiert
sein.
Es ist sinnvoll den Pfad zu dem FOP Verzeichnis in die Umgebungsvariablen unter
„Path“ einzutragen, damit man „fop.bat“ oder „fop.sh“ über die Comandozeile unter
beliebigem Verzeichnis starten kann.
Damit ist die Installation von FOP abgeschlossen.
29
1.3.3 FOP Konfiguration
Die FOP-Konfigurationsdatei ist eine XML Datei, die eine Vielzahl von Einstellungen
beinhaltet. Diese Einstellungen steuern das Verhalten des FOP und helfen die entsprechende Ressourcen zu finden. Die Aufbau einer Konfigurationsdatei ist in der Tabelle 1
dargestellt.
Die Konfigurationsdatei „userconfig.xml“ liegt unter {fop-Verzeichniss}/conf/. Wenn
man eine andere als Basiskonfiguration braucht, ist es zu empfählen die Datei
„userconfig.xml“ in ein anderes Verzeichnis zu kopieren.
Option (key)
Datentype (für den Inhalt)
baseDir
URL
Standardeinstellung für den Inhalt
Das ist Verzeichnis wo die FO oder
XML Dateien liegen
Für die Eingabeaufforderungskonsole ist es das aktuelle Verzeichnis.
fontBaseDir
URL
Inhalt der baseDir
Hyphenation
URL
Null.
directory
Dieser Eintrag enthält den Pfad zu
dem Verzeichnis, der kundenspezifische Silbentrennungsmuster beinhaltet.
fonts
URL
Null.
Pfad zu den Benutzerdefinierten
Fonts.
Tabelle 1 Übersicht über alle Knoten und Ihre Inhalte
30
FOP und Silbertrennung
Damit Silbentrennungsmuster auch funktionieren müssen folgende Bedingungen
berücksichtigt werden:
•
Die Sprache für den Inhalt muss in der XSL-Datei eingegeben werden. Dafür
wird Attribut „xsl:language="ru" “(für russisch) bei dem Element „<root>“ (für
den ganzen Inhalt) oder bei dem entsprechenden „<block>“(wenn man mehrsprachigen Inhatl verwendet). Als Alternative kann man die Sprache beim
Aufrufen von FOP per Attribut „-l“ einstellen.
fop -l ru foo.fo foo.pdf
•
Für das ganze Dokument (Element „<root>“) oder für die Einzelnen Blocks
unbedingt die Silbentrennung aktivieren:
o
hypenation="true"
o hypenation-push-character-count="2"
o hypenation-remain-character-count ="2"
Für die Blocks, die eine Silbertrennung brauchen, Textfluss auf textalign="justify"
setzen.
Benutzen eigener Silbentrennungsmuster
Es gibt Möglichkeit alternative Silbentrennungsmuster zu benutzen. Dafür braucht man
entsprechendes Silbentrennungsmuster. Die meistbenutzte Quelle für die verschiedenen
Silbentrennungsmuster ist CTAN TeX Archive1
Um die Silbentrennungsmuster auch in den FOP einsetzen zu können, müssen folgende
Schritte gemacht werden:
•
Konvertieren die Silbentrennungsmuster in UTF-8.
•
Ein XML Dokument erzeugen, das dem hyphenation.dtd entspricht. In dieses
Dokument alle Silbentrennungsmuster reinschreiben.
1
http://www.ctan.org/tex-archive/language/hyphenation/
31
•
Dieses Dokument dann als ru.xml (für russisches Silbentrennungsmuster) in einem Verzeichnis speichern. Den Pfad zu diesem Verzeichnis in der
Konfigurationsdatei unter „Hyphenation directory“ eingeben.
Benutzerdefinierte Fonts generieren
In
FOP
vorinstallierte
Mehrsprachigkeit
zu
Fonts
unterstützen
gewährleisten,
keine
müssen
Unicode-Zeichen.
benutzerdefinierte
Um
die
Unicode-Fonts
eingebunden werden.
Um die benutzerdefinierte Fonts einzubinden, werden die Metriken für diese Fonts
benötigt. Metrik ist eine XML Datei, in der alle Parameter des Bildzeichens gespeichert
sind.
FOP Distribution hat einen TTFReader, das die True-Type-Font ausliest und eine
passende Metrik erzeugt.
java -cp build\fop.jar;lib\avalon-framework.jar;lib\xml-apis.jar;
lib\xercesImpl.jar;lib\xalan.jar
org.apache.fop.fonts.apps.TTFReader
C:\myfonts\arial.ttf arial.xml
Nach dem die Metriken für alle gewünschte Fonts erstellt wurden, müssen die Pfade zu
diesen Dateien in der Konfigurationsdatei festgelegt werden.
In der Grundkonfiguration ist der Abschnitt mit den benutzerdefinierten Fonts
auskommentiert. Unter diesen Kommentaren stehen einige Beispiele für die
Konfiguration einzelnen Fonts.
<fonts>

<!—
<font metrics-file="arial.xml" kerning="yes" embed-file="arial.ttf">
<font-triplet name="Arial" style="normal" weight="normal"/>
<font-triplet name="ArialMT" style="normal" weight="normal"/>
</font>
</fonts>
Jedes Element „<font>“ beinhaltet die Pfade zu einer Metrik- und der Schriftsatzdatei.
32
Außerdem enthält das Element „<font>“ ein oder mehrere Tags „<font-triplet>“, mit
deren Hilfe die Menge von Synonymen für diesen Font beschrieben wird. In diesem
Beispiel werden diesem Font Synonyme Arial und ArialMT vergeben. Diese Namen
werden dann im XSL Datei für die „font-family“ eingegeben. Die Attribute „style“ und
„weight“ bestimmen den Schriftstill des Schriftsatzes. Im XSL werden diese Attribute
per Schlüsselwörter „font-style“ und „font-weight“ gesetzt. Es gibt vier Schriftstille für
den Schriftsatz:
•
Normal(style = “normal“, weight = “normal“)
•
Fett(style = “normal“, weight = „bold“)
•
Kursiv(style = „italic“, weight = „normal“)
•
Fett Kursiv(style = „italic“, weight = „bold“)
Das heißt, dass für jeden Schriftstill des Schriftsatzes ein Element „<font>“ erstellt werden muss.
1.3.4 Derzeitig von FOP unterstützte Formate des XSL-FO Standards
Zurzeit unterstützt FOP noch nicht vollständig den W3C XSL-FO 1.01 Standard.
Alle Elementen die von FOP unterstützt werden, sind in einer Tabelle eingetragen.
Diese Tabelle ist im Anhang A unter Von FOP unterstützte Formate zu finden. Die
Tabelle besteht aus drei Spalten: Element, derzeitigen Zustand und das Kommentar. Die
Spalte Zustand kann zwei Werte haben: „ja“ (vollständige Unterstützung), „teilweise“
(nicht vollständige Unterstützung).
Die aktuellste Information über unterstützte Formate findet man auf FOP-Hompage
2
[FOPAP]
1
http://www.w3.org/TR/xsl/
2
http://xml.apache.org/fop/compliance.html#fo-object
33
1.4 Erstellen von PDF Dokumenten mit Hilfe von FOP
1.4.1 Festlegen des Layouts
Projekt „Hebräische Typographie im deutschsprachigen Raum“ ist in zwei großen
Abschnitte aufgeteilt- „Typografie-Übersicht“ und „Bibliografie-Übersicht“. Jeder
Abschnitt ist wiederum auf mehrere Sichten verteilt. In der Abbildung 5 sind alle
Sichten des Projekts gezeigt. Die Sichten haben Namen und den Format, in dem sie
angezeigt werden.
Startseite
HTML
Typografie-Übersicht
HTML
Typografie-Historie
HTML
Typografie-Vergleich
HTML
PDF
Typografie-Detailsicht
HTML
HTML
PDF
PDF
Bibliografie-Übersicht
HTML
Bibliografie-Detailsicht
HTML
HTML
PDF
PDF
Schmuckstück-Detailsicht
HTML
HTML
Schmuckstück-Detailsicht
PDF
PDF
Abbildung 5 Seitenaufbau
Insgesamt sind es sieben Sichten, die das Format „PDF“ haben. Für diese Sichten muss
das Layout festgelegt werden.
Beim Erstellen des Layouts werden die Darstellungsformen von HTML-Ansichten nicht
übernommen. Man geht davon aus, dass die im PDF Format gespeicherte Information
34
später ausgedruckt werden kann. Deswegen muss das Layout so definiert sein, dass die
Information gut lesbar ist und auf ein Blatt Papier passt.
Grundlayouts
Als Grundlayout ist die Größe der einzelnen Seiten auf Papierformat A4 Quer oder
Hochformat festgelegt. Die Abstände vom Seitenrand betragen 10 mm.
Jede Seite hat drei Bereiche: Kopfzeile, Fußzeile und ein Hauptbereich.
10
mm
Fusszeile
mm
Hauptbereich
10
210 mm
Kopfzeile
40
mm
10
mm
297 mm
Abbildung 6 Layout Querformat
35
10
mm
Hauptbereich
10
Fusszeile
mm
297 mm
Kopfzeile
40
mm
10
mm
210 mm
Abbildung 7 Layout Hochformat
Die Kopfzeile ist 40 mm. hoch und ist mit dem Abstand 10 mm. von dem oberen
Seitenrand platziert. In der Kopfzeile wird die Beschriftung, horizontal in die Mitte,
platziert. Unter der Beschriftung wird, auch zentriert, das Logo von dem Projekt
dargestellt.
Abbildung 8 Logo
Die Beschriftung ist mit dem Font „Arial Fett“ und der Größe „14pt.“ dargestellt. Als
Hintergrundsfarbe wurde „grau" ausgewählt.
36
Die Fußzeile ist 10mm. hoch und unten platziert. Ihr Abstand von unterem Seitenrand
beträgt 10mm.. In der Fußzeile stehen, je nach Layout, Seitennummer und zusätzliche
Informationen.
Der Hauptbereich fängt mit dem Abstand 50mm. von dem oberen Seitenrand. Im
Hauptbereich werden Informationen, wie Schriftsätze, Seiten, Buchstaben, oder ihre
Eigenschaften, dargestellt.
Layouts
In dieser Sicht werden die Einzelnen Schriftsätze miteinander verglichen. Deshalb
müssen die einzelnen Schriftsätze untereinander stehen, um den Benutzer Möglichkeit
geben, diese miteinander zu Vergleichen und die Unterschiede sofort zu erkennen.
In der HTML-Sicht wurde es so realisiert, dass alle zu dem Schriftsatz gehörige
Informationen links von den Schriftsätzen stehen. Man sieht sofort welche Information
zu welchem Schriftsatz gehört. Leider beim Ausdrucken passen nicht alle Informationen
auf ein Blatt Papier Abbildung 9.
Im PDF-Sicht werden zuerst alle Schriftsätze dargestellt und nummeriert (Abbildung
10). Die zugehörigen Schriftsatzinformationen werden auf einem externen Blatt mit entsprechender Nummerierung platziert (Abbildung 11).
Dieses Layout besteht aus zwei Seitentypen: „Typografie-Vergleich“ und „Beschreibung“. Als Grundlayout für die beiden Seitentypen wurde Querformat (Abbildung 6)
ausgewählt.
37
Abbildung 9 Typografie-Vergleich HTML-Sicht
38
Abbildung 10 Typografie-Vergleich PDF-Sicht Seitentyp 1
39
Abbildung 11 Typografie-Vergleich PDF-Sicht Seitentyp 2
40
Der erste Seitentyp (Typografie-Vergleich).
In der Kopfzeile steht die Beschriftung „Typografie-Vergleich“.
Das ganze Hauptbereich ist als eine Tabelle mit 28 Spalten dargestellt. Die ersten 27
Zellen sind für die einzelnen Buchstaben vorgesehen. Die letzte Zelle ist für die laufende
Nummer des Schriftsatzes auf dieser Seite reserviert. Die Breite der Zellen für die
einzelnen Buchstaben beträgt 10 mm. Die Zelle für die laufende Nummer ist 7mm. breit.
Die Anzahl der Zeilen in der Tabelle ist von der Anzahl der zu vergleichenden
Schriftsätze abhängig. Auf eine Seite passt neun Schriftsätze. Wenn es mehr als neun
Schriftsätze zu vergleichen gibt, wird automatisch eine neue Seite von Typ „TypografieVergleich“ erstellt.
In der Fußzeile steht laufende Nummer der Seite.
Der zweite Seitentyp (Beschreibung).
In der Kopfzeile steht als Beschriftung „Beschreibung“.
Der Hauptbereich ist als eine Tabelle mit 5 Spalten dargestellt. Jede Spalte hat eigene
Breite. Die Tabelle hat folgende Spalten: „Nr“ ist die laufende Nummer des
Schriftsatzes (10 mm. breit), „Schriftsatzname“ (70 mm. breit), „Schriftstill“ (70 mm.
breit), „Schriftart“ (70 mm. breit) und „Jahr“ (57 mm. breit). Schriftart für die
Beschriftung der Tabelle ist mit dem Font „Arial Fett“ und der Größe „14pt.“ dargestellt.
Die Hintergrundsfarbe ist „grau“. Die Höhe des farbigen Bereichs beträgt 15mm. Die
Anzahl der Zeilen ist auf die Anzahl der Schriftsätze plus eine Zeile für die Beschriftung
gesetzt. Wenn es mehr Informationen gibt und die nicht mehr auf eine Seite passen, wird
automatisch eine neue Seite von Typ „Beschreibung“ erstellt.
In der Fußzeile steht links die laufende Nummer der Seite.
41
In dieser Ansicht wird einzelner Schriftsatz dargestellt. Das entsprechende Layout wurde
anders entworfen, als für die HTML-Sicht. In der HTML-Ansicht ist der ganze
Schriftsatz in der Tabelle mit fünf Spalten dargestellt, so dass in jeder Zeile nur fünf
Buchstaben reinpassen. Die Schriftsatzrelevante Information steht rechts von dem
Schriftsatz (Abbildung 12).
Für PDF Sicht ist es nicht notwendig, den Schriftsatz und die relevante Informationen
auf einem Blatt zu repräsentieren Deswegen wird der ganze Schriftsatz auf einer Linie
dargestellt (Abbildung 13). So können die Merkmalle einer Buchstabe sofort in dem
Zusammenhang mit den anderen Buchstaben des Schriftsatzes vergleichen. Die
dazugehörige Information ist auf der anderen Seite dargestellt (Abbildung 14). Das
Layout für diese Sicht besteht aus zwei Seitentypen, wobei jeder Seitentyp eigene
Eigenschaften und Informationen beinhalten kann.
Als Grundlayout für die beiden Seitentypen wurde das Querformat (Abbildung 6)
ausgewählt.
42
Abbildung 12 Schriftsatz-Detail HTML
43
Abbildung 13 Schriftsatzdetail Seitentyp 1
44
Abbildung 14 Schriftsatzdetail Seitentyp 2
45
Der erste Seteintyp (Typografie-Detailsicht).
In der Kopfzeile steht die Beschriftung „Typografie-Detailsicht“.
Der ganze Hauptbereich ist als eine Tabelle mit 27 Spalten dargestellt. Die Breite der
Spalten, die für die einzelnen Buchstaben vorgesehen sind, beträgt 10 mm. Die Anzahl
der Zeilen in der Tabelle ist von der Anzahl der darzustellenden Information abhängig.
Der Schriftsatz kann außer der Buchstaben selbst noch Sonderzeichen beinhalten. Es
gibt sechs Sonderzeichengruppen: Ausgedehnte Buchstaben, Betonungszeichen,
Ligaturen,
Satzzeichen,
Vokalzeichen
und
Variantenzeichen.
Wenn
diese
Sonderzeichengruppen in einem Schriftsatz existieren, werden die unter dem Schriftsatz
dargestellt. Es wird ermittelt, wie viele Sonderzeichen eines Typs existieren. Dann wird
die Anzahl der Spalten in der Tabelle auf die Anzahl der Sonderzeichen in der
Sonderzeichengruppe reduziert. Vertikale Abstand zwischen dem Schriftsatz und den
Sonderzeichengruppe
beträgt
10mm..
Der
Abstand
zwischen
einzelnen
Sonderzeichengruppen beträgt ebenfalls 10mm.
In der Fußzeile links steht die laufende Nummer der Seite. Rechts ist der Name des
Schriftsatzes mit dem Font „Arial Fett“ und der Größe „10pt.“, abgebildet. Unter dem
Schriftsatznamen steht der Buchname. Der Buchname ist mit dem Font „Arial“ und der
Größe „8pt.“ dargestellt.
Die Informationen, die in der Fußzeile rechts stehen sind notwendig, um die Zuordnung
der Blätter nach dem Ausdrucken zu erleichtern.
Der Hauptbereich ist als eine Tabelle mit 4 Spalten dargestellt. Jede Spalte hat eigene
Breite. Die Tabelle hat folgende Spalten: „Schriftsatzname“ (64mm. breit), „Schriftstill“
(58mm. breit), „Schriftart“ (58mm. breit) und „im Buch (Jahr)“ (97mm. breit). Schriftart
für die Beschriftung der Tabelle ist mit dem Font „Arial Fett“ und der Größe „14pt.“
dargestellt. Die Hintergrundsfarbe ist „grau“. Die Höhe des farbigen Bereichs beträgt
15mm. Die Information, die in die Tabelle eingetragen ist, ist mit dem Font „Arial“ und
46
Alle Informationen in der Tabelle werden mit dem Abstand „2mm.“ von dem linken
Zeilenrand platziert. In der Spalte „im Buch (Jahr)“ ist auch Abstand rechts auf 5 mm.
festgelegt, damit auch hebräische Schrift unter der Beschriftung dargestellt wird. Anzahl
der Zeilen ist auf Anzahl der Schriftsätze plus eine Zeile für die Beschriftung gesetzt.
Wenn es mehr Informationen gibt, und diese nicht auf eine Seite passen, wird
automatisch eine neue Seite von Typ „Beschreibung“ erstellt.
In der Fußzeile links steht die laufende Nummer der Seite. Rechts ist der Name des
Schriftsatzes, mit dem Font „Arial Fett“ und der Größe „10pt.“, abgebildet. Unter dem
Schriftsatznamen steht der Buchname. Buchname ist mit dem Font „Arial“ und der
47
In dieser Sicht werden einzelner Buchstabe und zu dem gehörige Informationen
dargestellt. Das Layout für diese Sicht ist fast identisch mit dem Layout in der HTMLSicht (Abbildung 15).
Abbildung 15 Buchstabe-Detail HTML
Der einzige Unterschied zwischen HTML und PDF Layout besteht darin, dass in der
HTML-Sicht der Buchstabe und seine Informationen zusammen nebeneinander stehen
und im PDF Layout werden die Buchstabenabbildung und die Informationen getrennt
auf zwei Seiten dargestellt. Zusätzlich hat PDF Layout auch andere Elemente, die das
HTML-Layout nicht hat. Das sind z.B. Fußzeile in der die Seitenanzahl und der Name
des Buchstabens stehen.
Die beiden Seiten basieren auf dem Grundlayout Hochformat (Abbildung 7).
48
Abbildung 16 Buchstabe-Detailsicht Seitentyp 1
49
Abbildung 17 Buchstabe-Detailsicht Seitentyp 2
50
Der erste Seitentyp (Buchstabe-Detailsicht)
In der Kopfzeile steht als Beschriftung „Buchstabe -Detailsicht“. Unter der Beschriftung
steht der Name der Buchstabe. Der Name von dem Buchstaben ist mit dem Font „Arial“
und der Fontgröße „12pt.“ dargestellt.
Im Hauptbereich wird nur ein großes Bild des Buchstabens dargestellt.
In der Fußzeile links steht laufende Nummer der Seite. Rechts in der Fußzeile steht der
Buchstabenname. Name des Buchstabens ist in der Fußzeile mit dem Font „Arial“ und
der Größe „8pt.“ dargestellt.
Der zweite Seitentyp (Beschreibung)
Der Hauptbereich von diesem Typen ist als Tabelle mit Zwei spalten und sechs Zeilen
dargestellt. In der linken Spalte stehen die Beschriftungen, und in der rechten- die
Informationen. Die Spalte für die Beschriftungen ist 60mm. breit, und die Spalte für die
Informationen ist 130mm. breit. Die Informationen werden mit dem Font „Arial“ und
Größe „12pt.“ dargestellt. Die Beschriftungen haben Font „Arial Fett“ und die
Schriftsatzgröße beträgt “12pt.“ Alle Beschriftungen sind rechtsbündig in ihren Zellen
platziert. Zusätzlich haben alle Beschriftungen einen grauen Hintergrund. Die Höhe des
Hintergrundsbereiches beträgt 5mm.
In der Fußzeile links steht laufende Nummer der Seite. Rechts steht der
Buchstabenname, der in der Fußzeile mit dem Font „Arial“ und der Größe „8pt.“
dargestellt ist.
51
In dieser Sicht wird das ganze Buch mit allen fotografierten: Seiten, Illustrationen und
Schmuckstücke gezeigt. Das Layout für diese Ansicht ist ebenfalls anders als in der
HTML-Sicht.
In
der
HTML-Sicht
sind
die
Buchseiten,
Illustrationen
und
Schmuckstücke als kleine Bilder dargestellt. Die buchrelevante Informationen stehen
rechts neben den Bildern. (Abbildung 18)
Abbildung 18 Bibliografie-Detailsicht HTML
Für PDF-Darstellung ist dieses Layout unpraktisch, da man an kleinen Bildern nicht viel
erkennen kann. Die Informationen, die in der HTML-Ansicht neben den Bildern stehen,
passen einfach nicht auf ein Blatt Papier und die Grundlayouts für die PDF Sichten
wurden so konzipiert, dass man diese ohne Mühe und Verzerrung auf einem DIN A4
Blatt Papier ausdrucken kann.
Deshalb werden alle Bilder im PDF-Sicht groß dargestellt, so dass nur ein Bild auf eine
Seite passt (Abbildung 19). Die dazugehörigen Informationen sind auf einem externen
Blatt repräsentiert (Abbildung 20).
52
Abbildung 19 Bibliografie-Detailsicht Seitentyp 1
53
Abbildung 20 Bibliografie-Detailsicht Seitentyp 2
54
Das Layout für Bibliografie-Detailsicht besteht aus zwei Seitentypen, wobei jeder
Seitentyp eigene Eigenschaften und Informationen beinhaltet. Als Grundlayout für den
ersten Seitentyp wurde Querformat (Abbildung 6) ausgewählt. Für die buchrelevanten
Informationen wurde Hochformat (Abbildung 7) als Grundlayout ausgewählt, um die
bessere Lesbarkeit der Informationen zu gewährleisten.
Der erste Seteintyp (Bibliografie-Detailsicht).
In der Kopfzeile steht als Beschriftung „Bibliografie-Detailsicht“.
Im Hauptbereich wird nur ein großes Bild dargestellt. Es wird automatisch so viele
Seiten erstellt, wie viele Bilder für dieses Buch existieren.
In der Fußzeile links steht die laufende Nummer der Seite. Rechts in der Fußzeile wurde
der Buchtitel platziert. Name des Buches ist in der Fußzeile mit dem Font „Arial“ und
der Größe „8pt.“ dargestellt.
Der zweite Seteintyp (Buchdaten).
In der Kopfzeile steht als Beschriftung „Bibliografie-Detailsicht“.
Der Hauptbereich dieses Typs ist als Tabelle mit Zwei Spalten und einundzwanzig
Zeilen dargestellt. In der linken Spalte stehen die Beschriftungen und in der rechten- die
Informationen. Die Spalte für die Beschriftungen ist 60mm. breit. Die Spalte für die
Informationen ist 130mm. breit. Die Informationen werden mit dem Font „Arial“ und
Größe „12pt.“ dargestellt. Die Beschriftungen haben Font „Arial Fett“ und die
Schriftsatzgröße beträgt „12pt.“. Alle Beschriftungen sind rechtsbündig in ihren Zellen
platziert. Zusätzlich haben alle Beschriftungen einen grauen Hintergrund. Die Höhe des
Hintergrundsbereiches beträgt 5mm. Hintergrundbereich wird automatisch vergrößert,
wenn die Informationen in der rechen Spalte nicht in eine Zeile passen.
In der Fußzeile steht links laufende Nummer der Seite, rechts- der Buchtitel. Der Name
des Buchstabens ist in der Fußzeile mit dem Font „Arial“ und der Größe „8pt.“
dargestellt.
55
Seite-Detailsicht
In dieser Sicht wird die einzelne Buchseite dargestellt. Der PDF Layout für diese Sicht
ist dem HTML Layout fast identisch (Abbildung 21).
Abbildung 21 Buchseite HTML
Der einzige Unterschied liegt in der Platzierung von Copyright. Im PDF-Sicht fehlen
auch Buttons und Links.
In der PDF-Sicht werden Bild und die Informationen auf einer Seite platziert (Abbildung
22).
56
Abbildung 22 Buchseite
57
Als Vorlage für dieses Layout dient Grundlayout Hochformat (Abbildung 7).
In der Kopfzeile steht als Beschriftung „Buchseite-Detailsicht“.
Im Hauptbereich wird der Name der Buchseite mit dem Font „Arial“ und Größe „12pt.“
dargestellt. Unter dem Namen wird das große Bild der Buchseite mittig platziert.
In der Fußzeile, linksbündig, steht Copyright für diese Buchseite. Das Copyright ist mit
dem Font „Arial“ und Schriftsatzgröße „8pt.“ dargestellt.
Illustration-Detailsicht und Schmuck-Detailsicht.
Die Layouts für die beiden Sichten sind absolut identisch, deswegen wird nur das
Schmuckstücklayout beschrieben.
Die Schmuckstücke und die Illustrationen besitzen gar keine Information. Deshalb
besteht die Sicht nur aus der Kopfzeile und dem Bild selbst. Das Layout ist für diese
Sicht auch nicht kompliziert. Das Layout basiert auf dem Grundlayout Hochformat
(Abbildung 7).
Kopfzeile hat als Beschriftung „Schmuck-Detailsicht“ bzw. „Illustration-Detailsicht“.
Der Hauptbereich besteht nur aus einem einzigen Bild. Dieses ist mittig auf der Seite
abgebildet (Abbildung 23).
58
Abbildung 23 Schmuck-Detailsicht
59
1.4.2 Erstellen XSL-FO Dokumenten
Nach dem alle Layouts für die entsprechenden Sichten festgelegt sind, müssen sie mit
Hilfe von XSL-FO beschrieben werden.
Alle Layouts basieren auf zwei Grundlayouts „Hochformat“ und „Querformat“. Diese
Grundlayouts dienen als Schablonen für alle Seiten. Im XSL werden zuerst diese
Schablonen vorbereitet. Die Schablone beinhaltet nur die Beschreibung der Seitengröße,
die Größe aller Bereihe auf der Seite und vordefinierte Merkmalle, wie Logo.
Alle Werte für die Seitengrößen werden in Millimeter „mm“ und die Werte für die
Fontgröße werden in Punkten „pt“ eingegeben. Die Größe für die Grafik wird ebenfalls
in Millimeter eingegeben.
Querformat:
In der Abbildung 6 ist die Struktur und die Größen des Grundlayouts gezeigt. Im XSL
werden diese Größen beschrieben.
<fo:layout-master-set>
<fo:simple-page-master master-name="querformat" pageheight="210mm" page-width="297mm" margin-top="10mm" marginbottom="10mm" margin-left="10mm" margin-right="10mm">
<fo:region-before extent="40mm"/>
<fo:region-after extent="10mm"/>
</fo:layout-master-set>
<fo:page-sequence master-reference="querformat">
<fo:block text-align="center">
<fo:external-graphic height="15mm" src="images/logo.gif"/>
</fo:block>
<fo:block text-align="center" font-family="Arial" font-size="14pt"
font-weight="bold" background-color="#EEEEEE">
TITEL
</fo:block>
<fo:block>
</fo:block>
60
<fo:block>
</fo:block>
</fo:flow>
</fo:page-sequence>
Der Tag „<fo:simple-page-master>“ beinhaltet folgende Parameter: die Höhe der Seite
„page-height="210mm"“, die Breite der Seite „page-width="297mm"“, Abstände von
den
Seitenrändern
bottom="10mm"“,
bis
zu
Seiteninhalt
„margin-top="10mm"“,
„margin-
“margin-left="10mm"“ und „margin-right="10mm"“. Der Tag
„<fo:region-before extent="40mm"/>“ beschreibt den Bereich für die Kopfzeile Der
Tag „<fo:region-body>“ beschreibt den Hauptbereich der Seite. Für diesen Bereich
wird ein Abstand von den oberen Seitengrenze „margin-top="40mm"“ gesetzt, weil
ohne dieses Abstandes werden die Inhalte von dem Hauptbereich, die Inhalte der
Kopfzeile überlappen. Aus dem gleichen Grund wird auch Freiraum für die Fußzeile von
unterer Seitengrenze bis zum Hauptbereich „margin-bottom="10mm"“ gelassen. Der
Tag „<fo:region-after extent="10mm"/>“ beschreibt die Höhe des Fußzeilebereiches.
Alle Layouts beinhalten in der Kopfzeile „<fo:static-content flow-name="xsl-regionbefore">“
ein Logo Abbildung 8. Dieses Logo wird in einem Block platziert und mittig
in der Kopfzeile dargestellt. Das Logo ist 15mm. hoch.
<fo:external-graphic height="15mm" src="images/logo.gif"/>
</fo:block>
Die Kopfzeile beinhaltet auch eine Beschriftung. Diese Beschriftung wird immer zentriert, mit dem gleichen Font, gleicher Größe und gleicher Hintergrundsfarbe für alle
Sichten dargestellt „<fo:block text-align="center" font-family="Arial" fontsize="14pt" font-weight="bold" background-color="#EEEEEE">“.
Der
Hauptbereich
„<fo:flow
flow-name="xsl-region-body">“
und
Fußzeile
„<fo:static-content flow-name="xsl-region-after">“ besitzen, je nach Sicht, unterschiedliche Merkmalle, deshalb werden diese Bereiche in der Schablone nicht belegt.
61
Hochformat:
<fo:layout-master-set>
<fo:simple-page-master master-name="hochformat" page-height="297mm"
page-width="210mm" margin-top="10mm" margin-bottom="10mm"
margin-left="10mm" margin-right="10mm">
<fo:region-before extent="40mm"/>
<fo:region-after extent="10mm"/>
Der einzige Unterschied zwischen der Schablone für Hochformat und der für Querformat ist die Breite page-width="210mm" und Höhe page-height="297mm" der Seite.
Alle innere Bereiche der Seite, in dieser Schablone, sind mit Querformatlayout identisch.
Sprachen
Im Projekt „Hebräische Typographie im deutschsprachigen Raum“ besteht die
Möglichkeit die Sprache zu wählen, bzw. zu wechseln. Im Projekt werden zurzeit vier
Sprachen unterstützt. Jede Sicht muss die Möglichkeit haben, die Informationen in
diesen Sprachen anzuzeigen. Dafür gibt es für jedes Layout eine entsprechende XML
Datei, die alle Begriffe in allen vier Sprachen beinhaltet. Die Informationen in dieser
Datei werden mit UTF-8 Kodierung gespeichert.
<?xml version="1.0" encoding="UTF-8"?>
<SchriftsaetzeVergleichSprache>

<sprache id="deutsch">
<titel>Typografie-Vergleich</titel>
<typografie>Typografie-Übersicht</typografie>
<sprachen>
<one>english</one>
<two>русский</two>
<three>‫<תירבע‬/three>
</sprachen>

<beschreibung>Beschreibung</beschreibung>
<schriftname>Schriftsatzname</schriftname>
<schriftstil>Schriftstil</schriftstil>
<schriftart>Schriftart</schriftart>
62
<jahr>Jahr</jahr>
<aktualisieren>aktualisieren</aktualisieren>
<altType>Detailansicht des Buchstabens</altType>
<drucken>PDF erzeugen</drucken>
<altDrucken>PDF erzeugen</altDrucken>
</sprache>
<!—Dateien für englisch und russisch-->
<!—Hebräisch-->
<sprache id="‫>"תירבע‬
<titel>‫<היפרגופיט האוושה‬/titel>
<typografie>‫<היפרגופיט תיצמת‬/typografie>
<sprachen>
<one>english</one>
<two>deutsch</two>
<three>русский</three>
</sprachen>

<beschreibung>‫<רואת‬/beschreibung>
<schriftname>‫<סופדה תוא םש‬/schriftname>
<schriftstil> ‫<סופדה תוא ןונגס‬/schriftstil>
<schriftart> ‫<סופדה תוא גוס‬/schriftart>
<jahr>‫<הנש‬/jahr>
<aktualisieren>‫<ןכדע‬/aktualisieren>
<altType>‫<טבמ בורק תואמ סופד וז‬/altType>
<drucken>PDF ‫<רוצ ץבוק‬/drucken>
<altDrucken> PDF ‫<רוצ ץבוק‬/altDrucken>
</sprache>
Diese Datei wird dann in einer entsprechenden XSL Datei eingebunden.
<xsl:variable name="xmlPfad">
<xsl:value-of select="//XMLPfad"/>Sprache.xml
</xsl:variable>
<xsl:variable name="transl" select="document($xmlPfad)"/>
Die Datei „Sprache.xml“ ist so aufgebaut, dass jede Sprache eine „ID“ besitzt. Als „ID“
dient der Sprachenname in jeweiliger Sprache. Unter dieser „ID“ befinden sich Tag, die
Informationen in der bestimmten Sprache beinhalten. Beim Erstellen von PDF Dokument wird abgefragt, in welcher Sprache dieses Dokument erstellt werden soll.
<xsl:variable name="sprache" select="//Sprache"/>
Und die Begriffe werden in entsprechender Sprache aus dieser XML-Datei ausgelesen
und angezeigt.
63
Layouts
Der komplette Quellkode von allen XSL-FO-Dateien ist in der beigelegten CD unter
dem Verzeichnis „XSL-FO“ zu finden.
Typographie-Vergleich
Der erste Seitentyp (Typografie-Vergleich).
Typografie-Vergleich basiert auf dem Grundlayout Querformat.
Die erste Seite hat den Namen „<fo:simple-page-master master-name="schriftsaetze"....“
Nachdem das Format der Seite ausgewählt und beschrieben wurde, wird die Seite mit
den Informationen gefüllt. Dafür wird die Seite aufgerufen „<fo:page-sequence masterreference="schriftsaetze">“.
Die Beschriftung in der Kopfzeile „<fo:static-content flow-name="xsl-region-before">“
wird aus der Datei „SchriftsatzVergleichSprache.xml“ ausgelesen.
<xsl:value-of
select="$transl/SchriftsaetzeVergleichSprache/sprache[@id=$sprache]/titel"/>
Da die Kopfzeile zum Grundlayout gehört, wird die hier nicht näher beschrieben.
Der Hauptbereich „<fo:flow flow-name="xsl-region-body">“ ist als eine Tabelle
dargestellt. Die Tabelle wird in einem Block mit fixierter Größe erstellt
„<fo:block><fo:table table-layout="fixed">“. Die einzelnen Zellen der Tabelle sind
vordefiniert und haben eine feste Breite „<fo:table-column column-width="10mm"/>“
für die Buchstaben, „<fo:table-column column-width="7mm"/>“ für die Nummerierung.
Die Schriftsätze werden in Körper der Tabelle geschrieben „<fo:table-body>“. Hier wird
ein Template „Schriftsatz“ aufgerufen „<xsl:apply-templates select="Schriftsatz"/>“.
Das Template „Schriftsatz“ „<xsl:template match="Schriftsatz">“ beinhaltet alle
Informationen über die Buchstaben und ihre Platzierung in der Tabelle. Die Buchstaben
werden alphabetisch dargestellt, so das der erste Buchstabe ganz rechts vor der
Nummerierung steht. Die Zellen der Tabelle werden von links nach rechts mit den
Bildern belegt. Der letzte Buchstabe „Taw“ des hebräischen Alphabets wird in der ersten
Zelle platziert.
<xsl:template match="Schriftsatz">
<fo:table-row>
64
<fo:table-cell text-align="right">
<fo:block>
<xsl:for-each select="Taw">
<fo:external-graphic
src="servlet/LadeBildServlet?typeKleinSchluessel={DruckTypeSchluessel}"/>
</xsl:for-each>
</fo:block>
</fo:table-cell>
…………………………………...
Zuerst wird der Buchstabe in der XML-Datei gesucht „<xsl:for-each select="Taw">“.
Sobald der Buchstabe gefunden ist, wird die Abbildung von dem in die Zelle platziert.
Wenn es keine Abbildung für diesen Buchstaben existiert, wird ein Schattenbild von
diesem Buchstaben ausgegeben.
src="servlet/ LadeBildServlet?typeKleinSchluessel={DruckTypeSchluessel}"/>.
Nachdem alle Buchstabenbilder geladen sind, wird die laufende Nummer für diesen
Schriftsatz vergeben. Die Nummerierung hängt von der Anzahl zu vergleichende
Schriftsätze.
<fo:table-cell>
<fo:block text-align="center" font-family="Arial" font-size="14pt" fontweight="bold" line-height="12mm">
<xsl:value-of select="position()"/>
</fo:block>
</fo:table-cell>
Die Nummerierung “<xsl:value-of select="position()"/>” wird mit den entsprechenden
Parametern in einem Block platziert “<fo:block text-align="center" font-family="Arial"
font-size="14pt" font-weight="bold" line-height="12mm">”.
Sobald alle zu vergleichende Schriftsätze geladen sind, schließt sich Template
„</xsl:template>“ und die Tabelle „</fo:table-body></fo:table>“. Anschließend wird die
Beschreibung von Hauptbereich geschlossen „</fo:flow>“.
Die Fußzeile „<fo:static-content flow-name="xsl-region-after">“ beinhaltet nur die Seitennummer „<fo:page-number/></fo:static-content>“.
Als letztes wird der Knoten für die Seitenbeschreibung geschlossen „</fo:pagesequence>“.
65
Beschreibung basiert auf dem Grundlayout Querformat.
Die Seite hat den Namen „<fo:simple-page-master master-name="beschreibung"....“.
Informationen gefüllt. Dafür wird die Seite aufgerufen „<fo:page-sequence masterreference="beschreibung">“.
wird aus der „SchriftsatzVergleichSprache.xml“ ausgelesen.
<xsl:value-of select=
"$transl/SchriftsaetzeVergleichSprache/sprache[@id=$sprache]/beschreibung"/>
dargestellt. Die Tabelle wird in einem Block mit fixierter Größe erstellt
vordefiniert und haben eine feste Breite. Es gibt insgesamt fünf Spalten mit
verschiedener Breite:
•
Nummerierung - <fo:table-column column-width="10mm"/>
•
Schriftname - <fo:table-column column-width="70mm"/>
•
Schriftstill - <fo:table-column column-width="70mm"/>
•
Schriftart - <fo:table-column column-width="70mm"/>
•
Jahr - <fo:table-column column-width="57mm"/>
Alle Beschriftungen für die Spalten, außer Beschriftung für die Nummerierung, werden
aus der Datei „SchriftsatzVergleichSprache.xml“ ausgelesen und in die Zellen platziert.
<fo:table-cell>
<fo:block font-family="Arial" font-size="14pt" font-weight="bold"
background-color="#EEEEEE" line-height="15mm">
"$transl/SchriftsaetzeVergleichSprache/sprache[@id=$sprache]/schriftname"/>
</fo:block>
</fo:table-cell>
Die Beschriftung für die Nummerierung wird, als einfacher Text, in der ersten Zelle
platziert.
66
<fo:table-cell>
<xsl:text>Nr </xsl:text>
</fo:block>
</fo:table-cell>
Die Parameter für die Beschriftungen werden nach dem vordefinierten Layout
festgelegt.
Nachdem die Beschriftungen in die Tabelle eingetragen sind, werden die Inhalte in die
Zellen geschrieben. Dafür wird in der XML-Datei untersucht „<xsl:for-each
select="Schriftsatz">“ und alle Inhalte der Knoten, die unter dem Knoten „Schriftsatz“
liegen, werden in die bestimmten Zellen platziert.
<xsl:for-each select="Schriftsatz">
<fo:table-row>
<fo:table-cell>
<fo:block font-family="Arial">
<xsl:value-of select="position()"/>
</fo:block>
</fo:table-cell>
<fo:table-cell>
<xsl:value-of select="Name"/>
</fo:block>
<fo:table-cell>
………………………….
</xsl:for-each>
Anschließend wird die Tabelle und Der Hauptbereich geschlossen.
</fo:table-body>
</fo:table>
</fo:block>
</fo:flow>
Die Fußzeile „<fo:static-content flow-name="xsl-region-after">“ beinhaltet nur die
Seitennummer „<fo:page-number/></fo:static-content>“.
Als letztes wird der Knoten für die Seitenbeschreibung geschlossen „</fo:pagesequence>“.
67
Typographie-Detailsicht
Der erste Seteintyp (Typografie-Detailsicht).
Typografie- Detailsicht basiert auf dem Grundlayout Querformat.
Die erste Seite hat den Namen „<fo:simple-page-master master-name="schriftsaetze"...“.
Nachdem das Format der Seite ausgewählt und beschrieben wurde, wird diese mit den
Informationen gefüllt. Dafür wird die Seite aufgerufen „<fo:page-sequence masterreference="schriftsaetze">“.
wird aus der Datei „SchriftsatzDetailSprache.xml“ ausgelesen.
<xsl:value-of
select="$transl/SchriftsatzDetailSprache/sprache[@id=$sprache]/titel"/>
dargestellt. Die Tabelle wird in einem Block mit fixierter Größe erzeugt
vordefiniert und haben feste Breite „<fo:table-column column-width="10mm"/>“ für die
Buchstaben. Der Schriftsatz wird in Körper der Tabelle geschrieben <fo:table-body>.
Die Buchstaben des Schriftsatzes werden genau so platziert, wie im TypografieVergleich Sicht.
Es gibt zwei Möglichkeiten PDF-Dokument aus dem Typografie-Detailsicht-HTML ein
PDF zu erzeugen: zuerst nur den Schriftsatz mit dazugehöriger Information, oder den
Schriftsatz mit Information und alle seine Sonderzeichen. Wenn nur der Schriftsatz
ausgegeben werden soll, wird der Hauptbereich an dieser Stelle geschlossen. Andersfalls
werden die Sonderzeichen dazugeladen. Die Sichten werden über eine Abfrage getrennt.
Es wird überprüft, ob die Sonderzeichen dargestellt werden müssen „<xsl:if
test="AnzeigeModus!='0'">“.
Sobald das Alphabet des Schriftsatzes platziert wurde, werden die Sonderzeichen
platziert. Um die Information zwischen dem Schriftsatz selbst und den Sonderzeichen
optisch besser zu trennen, wird der Körper der Tabelle erstmal geschlossen und dann
wieder geöffnet aber mit einem 10mm. Abstand von dem oberen Teil.
68
</fo:table-body>
<fo:table-body space-before.optimum="10mm">
Die Sonderzeichen sind in fünf Kategorien aufgeteilt: Ausgedehnte Buchstaben,
Betonungszeichen, Ligaturen, Satzzeichen, Vokalzeichen und Variantenzeichen. In
dieser Rheinfolge werden die auch ausgegeben. Das Platzierungsprinzip von allen
Sonderzeichen, außer Vokalzeichen, ist gleich, deswegen wird in dieser Arbeit nur die
Platzierung von Ausgedehnten Buchstaben beschrieben. Als erstes wird überprüft, ob
die Sonderzeichen dieser Art überhaupt für diesen Schriftsatz existieren „<xsl:if
test="Ausgedehnt!=''">“.
<fo:table-body space-before.optimum="10mm">
<xsl:if test="Ausgedehnt!=''">
<xsl:for-each select="Ausgedehnt">
<xsl:if test="(position() mod 27) = 1">
<xsl:text disable-output-escaping="yes"><fo:table-row></xsl:text>
</xsl:if>
<xsl:if test="position() = (last()+1-(last() mod 27))">
<fo:table-cell>
<xsl:attribute name="number-columns-spanned"><xsl:value-of
select="(position() + 26 - count(//Ausgedehnt))"/></xsl:attribute>
</fo:table-cell>
</xsl:if>
<fo:table-cell text-align="right">
<fo:block>
<fo:external-graphic height="12mm"
</fo:block>
</fo:table-cell>
<xsl:if test="((position() mod 27) = 0) or (position()=last())">
<xsl:text disable-output-escaping="yes"></fo:tablerow></xsl:text>
</xsl:if>
</xsl:for-each>
</xsl:if>
</fo:table-body>
Wenn die Zeichen existieren, werden die aus der XML-Datei ausgelesen „<xsl:for-each
select="Ausgedehnt">“ und in die Tabelle platziert. Beim platzieren wird überprüft, ob
die Divisionsrest von position() und 27 gleich 1 ist „<xsl:if test="(position() mod 27) =
1"><xsl:text disable-output-escaping="yes"><fo:table-row></xsl:text></xsl:if>“.
Wenn ja, wird eine neue Zeile erzeugt. Dieser Vergleich ist notwendig, da die Anzahl
von Zeichen variabel ist, und theoretisch mehr als 27 Zeichen beinhalten kann.
69
Alle Zeichen sollen in der Tabelle rechtsbündig platziert sein, das heißt wenn es weniger
als siebenundzwanzig Zeichen in einer Zeile sind, müssen die freien Zellen verbunden
sein. Das wird durch eine Abfrage „<xsl:if test="position() = (last()+1-(last() mod
27))">“ realisiert. In dieser Abfrage wird festgestellt, vor welchem Zeichen die freien
Zellen verbunden werden. Wenn es weniger als siebenundzwanzig Zeichen sind, werden
zuerst die freien Zellen verbunden „<fo:table-cell><xsl:attribute name="numbercolumns-spanned"><xsl:value-of select="(position() + 26 - count(//Ausgedehnt))"/>
</xsl:attribute></fo:table-cell>“. Nachdem alles für die Zeicheplatzierung vorbereitet
ist, werden die Zeilen in die richtigen Zellen platziert „<fo:external-graphic
height="12mm"src="servlet/LadeBildServlet?typeKleinSchluessel={DruckTypeSchlues
sel}"/>“. Und als die Zeile mit dem Inhalt belegt ist, wird die geschlossen „<xsl:if
test="((position() mod 27) = 0) or (position()=last())"> <xsl:text disable-output-escaping
="yes"></fo:table-row></xsl:text></xsl:if>“.
Detaillierte Beschreibung der Platzierung von Zeichen in einer Tabelle wird an einem
Beispiel gezeigt.
Beispiel:
In einem Schriftsatz existiert dreißig Betonungszeichen (Tabelle 2). Wenn Divisionsrest
von Zeichenposition und siebenundzwanzig gleich 1 ist, wird eine neue Zeile erzeugt. In
diesem Beispiel sind das die Zeichen eins und achtundzwanzig. Nachdem die Zeile
erzeugt ist, überprüft man, ob die Position des aktuellen Zeichens gleich achtundzwanzig
ist. Dieser Wert wird durch eine Formel „last()+1-(last() mod 27)“ermittelt, wobei
„last()“ die Position des Letzten Zeichens liefert. „last() mod 27“ gibt uns die „3“Anzahl von Zeichen, die in der letzten Zeile platziert werden. Wenn es der Fall ist,
werden zuerst vierundzwanzig Zellen verbunden. Die Zahl vierundzwanzig wird durch
die Formel „(position() + 26 - count(//Betonungszeichen))“ ermittelt. Danach werden die
restlichen Zeichen in die Zellen platziert.
1
2
3
4
5
6
7
8...24
25
26
27
...
70
28
29
30
Tabelle 2 Beispiel dynamische Zeichenplatzierung in einer Tabelle
Für die Platzierung von Vokalzeichen wird der gleiche Algorithmus, wie für die
Platzierung von Schriftsatzbuchstaben angewendet. Es gibt insgesamt dreizehn
Vokalzeichen. Die werden in der Tabelle rechtsbündig platziert. Dafür werden die ersten
vierzehn
Zellen
verbunden
„<xsl:attribute
name="number-columns-spanned">14
</xsl:attribute>“ und die restlichen mit den Zeichen gefüllt. Die Zeichen werden nach
ihren Namen gesucht und platziert „<xsl:for-each select="Vokalzeichen/Chirik">“.
Wenn die Abbildung dieses Zeichen existiert, wird die in die Zelle platziert
„<fo:external-graphic height ="12mm" src="servlet/LadeBildServlet? vokalzeichen
KleinSchluessel={DruckTypeSchluessel}"/>“, andernfalls wird ein Schattenbild von
diesem Vokalzeichen platziert.
Die Fußzeile „<fo:static-content flow-name="xsl-region-after">“ beinhaltet mehrere
Informationen. Um diese Informationen optisch besser zu trennen, wird eine Tabelle
„<fo:table table-layout="fixed">“ mit zwei Spalten erzeugt. Die erste Spalte ist 10mm.
breit „<fo:table-column column-width="10mm"/>“ und die zweite Spalte ist 267mm.
„<fo:table-column column-width="267mm"/>” breit. In die erste Zelle der Tabelle wird
die Nummer der Seite „<fo:page-number/>“ platziert. In die Zweite Zelle kommt der
Name des Schriftsatzes „<xsl:apply-templates select="Name"/>“ mit entsprechendem
Fonttyp und Fontgrösse „<fo:block font-family="Arial" font-size="10pt" fontweight="bold" text-align="right">“. Die Fußzeile beinhaltet auch die Namen der
Bücher, in deren dieser Schriftsatz vorkommt. Dafür wird eine neue Zeile erzeugt. In
dieser Zeile werden die beiden Zellen verbunden „<fo:table-cell number-columnsspanned="2">“. In dieser Zelle werden die Buchnamen rechtsbündig platziert
„<fo:block
font-family="Arial"
font-size="8pt"
font-weight="normal"
text-
align="right">“. Die Büchernamen werden über einen Template aufgerufen.
<xsl:apply-templates select="Buch"/>
71
Dieses Template ruft die Buchnamen aus der XSL-Datei auf „<xsl:value-of select=
"Name"/>“. Wenn es mehr als einen Buchnamen gibt, werden die Namen mit einem
Zeichen
„|“
voneinander
getrennt
„<xsl:text
disable-output-escaping="yes">
|
</xsl:text>“.
Der zweite Seteintyp (Beschreibung).
Beschreibung basiert auf dem Grundlayout Querformat.
Die Seite hat den Namen „<fo:simple-page-master master-name="beschreibung"...“.
den Information gefüllt. Dafür wird die Seite aufgerufen „<fo:page-sequence masterreference="beschreibung">“.
wird aus der „SchriftsatzDetailSprache.xml“ ausgelesen.
"$transl/SchriftsaetzeDetailSprache/sprache[@id=$sprache]/beschreibung"/>
Der Hauptbereich „<fo:flow flow-name="xsl-region-body">“ist als eine Tabelle
dargestellt. Die Tabelle wird in einem Block mit fixierter Größe erzeugt
vordefiniert und haben eine feste Breite. Es gibt insgesamt vier Spalten mit
verschiedener Breite:
Alle
•
Schriftname - <fo:table-column column-width="64mm"/>
•
Schriftstill - <fo:table-column column-width="58mm"/>
•
Schriftart - <fo:table-column column-width="58mm"/>
•
im Buch (Jahr) - <fo:table-column column-width="97mm"/>
Beschriftungen
für
die
Spalten
werden
aus
der
Datei
„SchriftsatzDetailSprache.xml“ ausgelesen. und in die Zellen platziert.
<fo:table-cell>
"$transl/SchriftsaetzeVergleichSprache/sprache[@id=$sprache]/schriftname"/>
72
</fo:block>
</fo:table-cell>
Alle Parameter für die Beschriftungen werden nach dem vordefinierten Layout
festgelegt.
Nachdem die Beschriftungen in die Tabelle eingetragen sind, wird eine neue Zeile
erstellt und alle Informationen, außer Information über Buch und Jahr, in die
entsprechenden Zellen geschrieben.
<fo:table-cell text-align="left" padding-left="2mm">
<fo:block font-family="Arial" font-size="12pt" font-weight="normal">
</fo:block>
</fo:table-cell>
Die Platzierung von Informationen in der Spalte „im Buch (Jahr)“ ist anders. Da es
mehrere Informationen in die Zelle platziert werden, beinhaltet diese noch eine Tabelle.
Diese Tabelle besteht nur aus einer Spalte und mindestens aus zwei Zeilen: für den
Buchnamen und das Jahr.
<fo:table-cell text-align="left" padding-right="2mm">
<fo:table table-layout="fixed">
<fo:table-column column-width="95mm"/>
<fo:table-body>
<xsl:for-each select="Buch">
<fo:table-row>
<fo:table-cell>
<xsl:apply-templates select="Name"/>
</fo:block>
</fo:table-cell>
</fo:table-row>
<fo:table-row>
<fo:table-cell>
(
<xsl:value-of select="Jahr"/>
)
</fo:block>
</fo:table-cell>
</fo:table-row>
</xsl:for-each>
</fo:table-body>
73
</fo:table>
</fo:table-cell>
Die XML-Datei wird nach dem Knoten „Buch“ untersucht. Dieser Knoten beinhaltet
weitere Knoten: „Name“ und „Jahr“.
In der ersten Zeile wird der Buchname „<xsl:apply-templates select="Name"/>“
platziert. Die zweite Zeile beinhaltet das Jahreszahl in den runden Klammern
„(<xsl:value-of select="Jahr"/>)“. Wenn es mehr als einen Buch mit diesem Schriftsatz
gibt, werden weitere zwei Zeilen erzeugt, für den Buchnamen und den Jahr.
Anschließend wird die Tabelle und die Zelle geschlossen. „</fo:table-body>
</fo:table></fo:table-cell>”.
Nachdem alle Informationen platziert sind, wird die Tabelle und der Hauptbereich
geschlossen.
</fo:table-body>
</fo:table>
</fo:block>
</fo:flow>
Die Fußzeile „<fo:static-content flow-name="xsl-region-after">“ ist genau so aufgebaut,
wie die Fußzeile für den ersten Seteintyp (Typografie-Detailsicht).
Als letztes wird der Knoten für die Seitenbeschreibung geschlossen “</fo:pagesequence>“.
Der erste Seitentyp (Buchstabe-Detailsicht).
Buchstabe-Detailsicht basiert auf dem Grundlayout Hochformat.
Die erste Seite hat den Namen „<fo:simple-page-master master-name="drucktype"...“.
den Informationen gefüllt. Dafür wird die Seite aufgerufen „<fo:page-sequence masterreference="drucktype">“.
wird aus der Datei „DruckTypeDetailSprache.xml“ ausgelesen.
74
<xsl:value-of
select="$transl/DruckTypeDetailSprache/sprache[@id=$sprache]/titel"/>
Im Hauptbereich „<fo:flow flow-name="xsl-region-body">“ wird nur ein großes Bild
des Buchstabens dargestellt.
<fo:block>
src="servlet/LadeBildServlet?typeGrossSchluessel={BildGross}"/>
</fo:block>
</fo:flow>
In der Fußzeile „<fo:static-content flow-name="xsl-region-after">“ links steht die
laufende Nummer der Seite „<fo:page-number/>“. Rechts in der Fußzeile steht der
Buchstabenname „<xsl:value-of select="Name"/>“.
<fo:block text-align="right" font-family="Arial" font-weight="normal" fontsize="8pt">
</fo:block>
<fo:page-number/>
</fo:block>
Der zweite Seitentyp (Beschreibung)
Beschreibung basiert auf dem Grundlayout Hochformat.
den Informationen gefüllt. Dafür wird die Seite aufgerufen „<fo:page-sequence masterreference="beschreibung">“.
wird aus der Datei „DruckTypeDetailSprache.xml“ ausgelesen.
"$transl/DruckTypeDetailSprache/sprache[@id=$sprache]/beschreibung"/>
Der Hauptbereich „<fo:flow flow-name="xsl-region-body">“ ist als eine Tabelle mit
zwei Spalten und sechs Zeilen dargestellt. Die Tabelle wird in einem Block mit fixierter
Größe erzeugt „<fo:block><fo:table table-layout="fixed">“. Die Spalten der Tabelle
sind vordefiniert und haben eine feste Breite:
75
•
Erste Spalte - <fo:table-column column-width="60mm."/>
•
Zweite Spalte - <fo:table-column column-width="130mm."/>
Die linke Spalte der Tabelle beinhaltet Beschriftungen. In die rechte Spalte werden die
Informationen platziert.
<fo:table-row>
<fo:table-cell padding-right="5mm" background-color="#EEEEEE">
<fo:block font-family="Arial" font-size="12pt" font-weight="bold" lineheight="5mm" text-align="right">
<xsl:value-of
select="$transl/DruckTypeDetailSprache/sprache[@id=$sprache]/schriftname"/>
</fo:block>
</fo:table-cell>
<fo:table-cell>
<xsl:value-of select="Schriftname"/>
</fo:block>
</fo:table-cell>
</fo:table-row>
Die Beschriftungen werden rechtsbündig platziert mit einem Abstand von 5mm. von der
rechten
Zellengrenze
„<fo:table-cell
padding-right="5mm"
background-color=
"#EEEEEE" >“. Die Informationen werden in der rechten Spalte linksbündig dargestellt
„<xsl:value-of select="Schriftname"/>“.
Die einzelnen Zeilen werden mit 2mm. Abstand voneinander erzeugt. Dafür wird der
Tabellenkörper zuerst geschlossen und dann wieder geöffnet mit dem entsprechenden
Abstand „</fo:table-body><fo:table-body space-before.optimum= "2mm">“.
Die Fußzeile ist identisch aufgebaut wie bei dem ersten Seitentyp (BuchstabeDetailsicht).
Alle Parameter für die Beschriftungen und Informationsdarstellung werden nach dem
vordefinierten Layout festgelegt.
76
Der erste Seitentyp (Bibliografie-Detailsicht).
Bibliografie-Detailsicht basiert auf dem Grundlayout Querformat.
Die erste Seite hat den Namen „<fo:simple-page-master master-name="buecher"...“.
den Informationen gefüllt. Dafür wird die Seite aufgerufen „<fo:page-sequence masterreference="buecher">“.
wird aus der Datei „BuchDetailSprache.xml“ ausgelesen.
<xsl:value-of
select="$transl/BuchDetailSprache/sprache[@id=$sprache]/titel"/>
Der Hauptbereich „<fo:flow flow-name="xsl-region-body">“ ist als eine Tabelle mit einer Spalte dargestellt. Die Tabelle wird in einem Block mit fixierter Größe erzeugt
<fo:block><fo:table table-layout="fixed">. Die Zelle der Tabelle ist vordefiniert und hat
eine feste Breite „<fo:table-column column-width="277mm"/>“. Die XML-Datei wird
nach den Seitenbildern“<xsl:for-each select="Seite">“, Illustrationen „<xsl:for-each
select="Illustration">“
select="Schmuckstueck">“
und
Schmuckstücke
„<xsl:for-each
untersucht und die Bilder jeweils in eine Zeile platziert.
<fo:table-row>
<fo:table-cell>
<xsl:for-each select="Seite">
src="servlet/LadeBildServlet?seiteGrossSchluessel={BildKlein}"/>
</xsl:for-each>
</fo:block>
</fo:table-cell>
</fo:table-row>
In der Fußzeile links steht laufende Nummer der Seite „<fo:page-number/>“. Rechts in
der Fußzeile steht der Buchtitel „<xsl:value-of select="Name"/>“.
<fo:block font-family="Arial" font-size="8pt" font-weight="normal" textalign="right">
77
</fo:block>
<fo:block>
<fo:page-number/>
</fo:block>
Der zweite Seteintyp (Buchdaten).
Seteintyp (Buchdaten) basiert auf dem Grundlayout Hochformat.
den Informationen gefüllt. Dafür wird die Seite aufgerufen „<fo:page-sequence masterreference="beschreibung">“.
wird aus der „BuchDetailSprache.xml“ ausgelesen.
"$transl/BuchDetailSprache/sprache[@id=$sprache]/beschreibung"/>
Der Hauptbereich „<fo:flow flow-name="xsl-region-body">“ist als eine Tabelle mit
zwei Spalten und einundzwanzig Zeilen dargestellt. Die Tabelle wird in einem Block mit
fixierter Größe erzeugt „<fo:block><fo:table table-layout="fixed">“. Die Spalten der
Tabelle sind vordefiniert und haben eine feste Breite:
•
Erste Spalte - <fo:table-column column-width="60mm."/>
•
Zweite Spalte - <fo:table-column column-width="130mm."/>
Die linke Spalte der Tabelle beinhaltet Beschriftungen. In der rechten Spalte werden die
Informationen dargestellt.
<fo:table-body>
<fo:table-row>
<fo:table-cell background-color="#EEEEEE" >
<fo:block font-family="Arial" font-size="12pt" font-weight="bold" lineheight="5mm" text-align="right">
<xsl:value-of
select="$transl/BuchDetailSprache/sprache[@id=$sprache]/buchTitel"/>
</fo:block>
78
</fo:table-cell>
<fo:table-cell padding-left="5mm">
</fo:block>
</fo:table-cell>
</fo:table-row>
</fo:table-body>
Die Beschriftungen „<xsl:value-of select="$transl/BuchDetailSprache/sprache[@id=
$sprache]/buchTitel"/>“
werden rechtsbündig platziert mit einem Abstand von 5mm.
von der rechten Zellengränze „<fo:table-cell padding-right="5mm" background-color=
"#EEEEEE">“. Die Informationen werden in der rechten Spalte linksbündig dargestellt
„<xsl:value-of select="Name"/>“.
Die einzelnen Zeilen werden mit 2mm. Abstand voneinander getrennt. Dafür wird der
Tabellenkörper zuerst geschlossen und dann wieder geöffnet mit dem entsprechenden
Abstand „</fo:table-body><fo:table-body space-before.optimum= "2mm">“.
Die Fußzeile ist identisch aufgebaut wie in dem ersten Seitentyp (BibliografieDetailsicht).
Seite-Detailsicht
Seite-Detailsicht basiert auf dem Grundlayout Hochformat.
Die Seite hat den Namen „<fo:simple-page-master master-name="eineseite"...“.
den Informationen gefüllt. Dafür wird die Seite aufgerufen „<fo:page-sequence masterreference="eineseite">“.
wird aus der Datei „SeiteDetailSprache.xml“ ausgelesen.
<xsl:value-of
select="$transl/SeiteDetailSprache/sprache[@id=$sprache]/titel"/>
79
Im Hauptbereich wird der Name der Buchseite „<xsl:value-of select="Name"/>“
dargestellt. Unter den Namen wird das große Bild der Buchseite „<fo:external-graphic
src="servlet/LadeBildServlet?seiteGrossSchluessel={BildGross}"/>“ platziert.
<fo:flow font-family="Arial" font-size="12pt" font-weight="normal" flowname="xsl-region-body">
</fo:block>
<fo:block>
src="servlet/LadeBildServlet?seiteGrossSchluessel={BildGross}"/>
</fo:block>
</fo:flow>
</fo:page-sequence>
In der Fußzeile „<fo:static-content flow-name="xsl-region-after">“ steht Copyright
für diese Buchseite. Copyright wird aus mehreren Parametern zusammengesetzt,
Copyrightzeichen- „<xsl:value-of select="$transl/SeiteDetailSprache/copyright"/>“,
dem Besitzer- „<xsl:value-of select="Besitzer"/>“ und dem Besitzerort- „<xsl:valueof select="BesitzerOrt"/>“,
wenn dieser existiert „<xsl:if test="BesitzerOrt!=''">“.
Die Informationen über Besitzer und Besitzerort werden durch ein Komma voneinander
getrennt „<xsl:text disable-output-escaping="yes">, </xsl:text>“.
Illustration-Detailsicht und Schmuck-Detailsicht
Illustration-Detailsicht und Schmuck-Detailsicht sind absolut identisch aufgebaut, deswegen wird nur der Schmuck-Detailsicht beschrieben.
Schmuck-Detailsicht basiert auf dem Grundlayout Hochformat.
Die Seite hat den Namen „<fo:simple-page-master master-name="eineseite"...“.
den Informationen gefüllt. Dafür wird die Seite aufgerufen „<fo:page-sequence masterreference="eineseite">“.
80
wird aus der Datei „SchmuckDetailSprache.xml“ ausgelesen.
<xsl:value-of
select="$transl/SchmuckDetailSprache/sprache[@id=$sprache]/titel"/>
Im Hauptbereich wird Name des Schmuckstückes „<xsl:value-of select="Name"/>“
dargestellt. Unter den Namen wird das große Bild des Schmuckstückes „<fo:externalgraphic
src="servlet/LadeBildServlet?seiteGrossSchluessel={BildGross}"/>“
plat-
ziert.
</fo:block>
<fo:block>
src="servlet/LadeBildServlet?schmuckGrossSchluessel={BildGross}"/>
</fo:block>
</fo:flow>
81
1.4.3 Implementierung FOP Methoden in das Projekt
Um aus der erzeugten XSL-FO-Dateien einen PDF-Dokument erzeugen zu können,
müssen folgende Funktionen implementiert werden
•
Funktionen für das Erzeugen von XML-Datei.
•
Funktionen für die Transformation von der XML-Datei mit den vorhandenen
XSL-FO Datei in eine FO-Datei.
•
Funktionen für das Konvertieren die erstellte FO-Datei in einen PDF-Dokument.
Erzeugen von allen Projektsichten (HTML oder PDF) erfolgt serverseitig. Durch den
Aufruf der aktuellen Web-Seite, wird eine Anfrage(reguest) an Server geschickt. Am
Server wird diese Anfrage bearbeitet und eine Antwort(response) an den Benutzer im
Form von HTML oder PDF zurückgegeben Abbildung 24.
Die Bearbeitung der Anfrage erfolgt über das Servlet „HebrewSchowServlet“. Dieses
Servlet wird nur einmal gestartet. Beim initialisieren vom Servlet, erzeugt es eine
Verbindung zu der Datenbank und füllt die Datenstruktur, die durch die Fachklassen
beschrieben wird, mit den Daten aus der Datenbank.
Nachdem das Servlet gestartet wurde, besteht die Möglichkeit die Anfragen zu
bearbeiten. Der Benutzer startet die Projektseite. Dabei wird eine Anfrage an das Servlet
geschickt. Das Servlet „HebrewSchowServlet“ überprüft, ob eine Session besteht oder
eine neue erzeugt werden muss. Beim ersten Zugriff auf die Projektseite besteht noch
keine Session. Es wird die Klasse „Dispatcher“ aufgerufen und eine Session erzeugt. Die
Klasse „Dispatcher“ erzeugt aus den Fachklassen Modelle. Danach wird die Anfrage
analysiert und weist den entsprechenden Steuer an, die betroffenen Modelle sich neu zu
generieren, oder zu aktualisieren. Als die Modelle aktualisiert wurden, ruft „Dispatcher“
für die angefragte Sicht den verantwortlichen Transformer auf. Dieser Transformer
überprüft die Aktualität der Sicht und erzeugt einen neuen XML-Baum. Der XMLBaum wird im Transformer mit dem entsprechenden XSL-Datei transformiert und in
einem, von dem Benutzer gewünschten Format (HTML oder PDF), an den
Benutzer(Client) zurückgeschickt.
82
Client
responce
Typografie Detailsicht
request
request
responce (HTML oder PDF)
HebrewSchowServlet
LadeBildServlet
Controller
request
Dispatcher
SchriftsatzDetailSteuer
SchriftsatzDetailTransformer
View
erzeugeHTML
erzeugePDF
XSL
SchriftsatzDetail
XSL-FO
SchriftsatzDetail_pdf
Server
XML(Sprache)
SchriftsatzDetailSprache
XML
SchriftsatzDetailSicht
Model
SchriftsatzDetailModell
HebrewType Datamodel
JDBC
Datenbank
Abbildung 24 Die Model-View-Controller Architektur (am Beispiel von Typografie Detailsicht)
83
Die Implementierung der Funktionen für das Erzeugen von PDF Dateien ist für alle
Sichten gleicht. Deshalb wird hier nur die Implementierung der Funktionen für die
Typografie Detailsicht gezeigt. Die HTML-Seite der Typografie-Detailsicht enthält
einen Button „PDF erzeugen“. Beim Erzeugen dieser Seite wurde serverseitig ein DOMObjekt erzeugt. Dieses DOM-Objekt enthält schon alle für den PDF-Dokument
notwendige Informationen. Beim aktivieren des Buttons wird die Methode
„erzeugePDF“ der Klasse „SchriftsatzDetailTransformer“ aufgerufen. In dieser Methode
wird zuerst der Ausgabeformat bestimmt.
response.setContentType("application/pdf");
Es wird für diese Klasse ein Objekt „log“ der Klasse „Logger“ erzeugt. Mit Hilfe von
diesem Objekt wird gesetzt, wie und in welcher Form die Warnungen ausgegeben
werden. In diesem Fall werden die Fehler in der Konsole ausgegeben.
if(log == null) {
log = new ConsoleLogger(ConsoleLogger.LEVEL_WARN);
MessageHandler.setScreenLogger(log);
}
Der aktuelle DOM Objekt „schriftsatzDetailDoc“ wird in einen XML-Baum
transformiert. Es wird der Ausgabeformat „format“ des DOM Objekts übernommen und
ein neuer Stringstrom „stringOut“ erzeugt. Ein neues XMLSerializer wird erzeugt, der
als Ausgabestrom den „stringOut“ und als Ausgabeformat „format“ benutzt. Per Befehl
„serial.serialize( schriftsatzDetailDoc)“ wird DOM Objekt in einem Stringstrom als
XML-Baum umgewandelt.
OutputFormat format = new OutputFormat(schriftsatzDetailDoc);
StringWriter stringOut = new StringWriter();
XMLSerializer serial = new XMLSerializer(stringOut, format);
serial.serialize(schriftsatzDetailDoc);
Aus diesem Stringstrom wird dann, über einen String, ein Sourceobjekt erzeugt.
StringReader stringReader = new StringReader(stringOut.toString());
Source xmlSource = new StreamSource(stringReader);
Nachdem der XML-Source existiert, wird er mit der XSL-FO-Datei transformiert. Dafür
wird die entsprechende XSL-FO-Datei zuerst geladen.
String XSLUrl = XSLPfad + "SchriftsatzDetail_pdf.xsl";
Source xslSource = new StreamSource(new URL(XSLUrl).openStream());
84
Um den FO-Strom erzeugen zu können, wird ein Objekt „resultWriter“ der Klasse
„StringWriter“ erzeugt. Dieses erlaubt dynamische Speichern von Stringinformationen.
Über das Objekt „result“ der Klasse „StreamResult“ wird die Information in
„resultWriter“ gespeichert.
StringWriter resultWriter = new StringWriter();
StreamResult result = new StreamResult(resultWriter);
Das Formen der FO Strom wird über Klassen „TransformerFactory“ und „Transformer“
eingeleitet. „TransformerFactory“ erzeugt den XSLT-Prosessor, der die Formung
vornehmen wird. Dieser wird im Objekt „tFactory“ gespeichert und über
„newInstance()“ erzeugt. Um den XSLT Prozessor zu aktivieren, wird das Objekt
„transformer“ der Klase „Transformer“ erzeugt. Dieses Objekt ist ein konkreter XSLT
Prozessor, der über „tFactory.newTransformer(xslSource);“ aktiviert wird. An die
Methode „newTransformer()“ wird der Datenstrom mit den XSL-Informationen
übergeben. Der XML-Strom wird über die Methode „transform(xmlSource, result)“ mit
dem XSL-Strom in den FO-Strom transformiert.
TransformerFactory tFactory = TransformerFactory.newInstance();
Transformer transformer = tFactory.newTransformer(xslSource);
transformer.transform(xmlSource, result);
Der, aus dem XML-Strom und XSL-FO-Datei, erzeugte FO-Datenstrom wird in ein
PDF-Dokument transformiert. Aber zuerst wird die Kodierung im FO-Strom geändert.
Alle XML-Bäume und XSL-Dateien benutzen „UTF-8“ Zeichen. Beim Speichern
werden diese aber in „ISO“ Zeichen umgewandelt. Dabei wird jedes „UTF-8“ Zeichen
auf zwei „ISO“ Zeichen zerlegt.
Wenn aus diesem FO-Strom ein PDF-Dokument erzeugt wird, kommen anstatt der
richtigen Zeichens zwei „ISO“ Zeichen. Um die richtige Ausgabe im PDF-Dokument zu
ermöglichen, wird der FO-Strom in einen FO-String mit „UTF-8“ Kodierung
umgewandelt.
String text = resultWriter.toString();
byte[] data = text.getBytes("iso-8859-1");
String utfText = new String(data, "UTF-8");
Alle Stringströme werden geschlossen.
stringOut.close();
stringReader.close();
85
resultWriter.close();
Der FO-Strom ist in der richtigen Kodierung gespeichert. Aus diesem Stringstrom wird
ein PDF-Dokument mit Hilfe von FOP-Methoden erzeugt.
Es wird ein Objekt „driver“ der Klasse „Driver“ erzeugt.
Driver driver = new Driver();
Dieses Objekt erzeugt aus dem FO-String einen Dokument in einem angegebenen
Format. Der Ausgabeformat wird über die Methode „setRenderer()“ bestimmt. Für das
Erstellen
von
PDF-Ausgabeformat,
wird
diese
Methode
eine
Konstante
„driver.RENDER_PDF“ übergeben.
driver.setRenderer(driver.RENDER_PDF);
Über den Objekt „options“ der Klasse „Options“ wird eine Konfigurationsdatei mit den
benutzerdefinierten Fonts eingebunden „new Options(userConfigStream)“.
Der Pfad zu der Konfigurationsdatei wird aus der „Propertydatei“ ausgelesen.
private String userConfig =
java.util.ResourceBundle.getBundle("hebtyp").getString("userConfig");
Der Inhalt der Konfigurationsdatei wird in einem Objekt „userConfigStream“ der Klasse
„InputSource“ als Eingabestrom gespeichert.
InputSource userConfigStream = new InputSource(new
URL(userConfig).openStream());
Options options = new Options(userConfigStream);
Der FO-String „utfText“ wird durch Methode „ setInputSource()“ dem Objekt „driver“
als Source „new InputSource(new StringReader(utfText))“ übergeben.
driver.setInputSource(new InputSource(new StringReader(utfText)));
Die Methode „setOutputStream“ bestimmt den Ausgabestrom. Als Ausgabestrom wird
„response.getOutputStream()“ gesetzt.
driver.setOutputStream(response.getOutputStream());
Die Methode „setLogger()“ gibt alle Fehlermeldungen aus, die während des Erzeugens
von PDF-Dokument auftretten können.
driver.setLogger(log);
Nachdem alle notwendige Einstellungen für das Objekt „driver“ gesetzt wurden, startet
die Transformation über die Methode „run()“.
driver.run();
86
Der PDF-Dokument wird erzeugt und als Antwort(response) an den Benutzer(Client)
geschickt.
Der Quellkode für die Transformation von FO in PDF-Dokument ist im Anhang A unter
Source Code zu finden.
1.5
Erste Ergebnisse und Erkenntnisse
Die ersten Ergebnisse waren recht positiv. Ein PDF-Dokument lies sich erzeugen. Die
Darstellung der Seiten entsprach dem vorgegebenen Layout. Beim Mehrseitigen
Dokumenten wurden die Seiten auch automatisch erzeugt. Das Problem lag in der
Darstellung von Schriftzeichenbildern. Alle Schriftzeichenbilder hatten gleiche Breite
und Höhe. Deshalb waren solche Merkmale des einzelnen Buchstabens wie: die Breite,
Höhe und die Positionierung nicht erkennbar.
So z.B. waren die Buchstaben „‫(“א‬Alef) , „‫(“י‬Jod) , „‫(“ל‬Lamed) und „‫( “ק‬Kof) gleich
Groß (Abbildung 25). Man konnte überhaupt nicht erkennen, dass die Buchstabe
„‫(“י‬Jod) die kleinste ist, oder die Buchstabe „‫(“ל‬Lamed) eine Oberlänge hat.
In der Abbildung 25 ist das erste Ergebnis von Erzeugen des PDF-Dokuments für die
Typografie-Vergleich Sicht. Man sieht, dass alle Schriftzeichenbilder gleich Groß sind.
Die Schriftzeichenbilder:
•
mit einer roten Umrandung - besitzen eigentlich eine Unterlänge
•
mit einer roten Umrandung und gestrickter Linie - besitzen in manchen Fällen
eine Unterlänge
•
mit einer blauen Umrandung haben- besitzen eine Oberlänge
•
mit einer schwarzen Umrandung - ist die kleinste Buchstabe in dem Alphabet.
87
Abbildung 25 Erste Ergebnisse (Typografie Vergleich)
88
Dieses Darstellungsproblem ließ sich nicht mit den Mitteln des XSL-FO Mechanismus
zu lösen. Man brauchte einen Mechanismus, der die proportionale Skalierung der
Schriftzeichenbildern ermöglichte. Dieser Mechanismus wird in dem zweiten Teil
„Ausrichtung von hebräischen Schriftzeichenbildern“ dieser Arbeit beschrieben.
1.6
Hebräische Zeichen in PDF
1.6.1 Problembeschreibung(bei „Right to Left“ Sprachen)
Das zweite Problem beim Erstellen von PDF-Dokumenten trat auf, wenn die
Beschriftungen oder Kommentare im Hebräisch ausgegeben wurden. Im PDF-Dokument
wurden die Hebräischen Zeichen zwar ohne Probleme dargestellt, aber die Laufrichtung
der Zeichen in einem Wort war vollkommen falsch. Die Hebräische Sprache gehört zu
so genannten „Right to Left“ Sprachen. Das bedeutet, dass im Hebräisch von rechts nach
links und von oben nach unten geschrieben wird. Beim Erzeugen von PDF-Dokumenten
wurde das nicht berücksichtigt.
So wird z.B. der Satz „HALLO WELT“ als „TLEW OLLAH“ dargestellt.
Die Behandlung solcher Fälle ist im XSL-FO vorgesehen (<fo:bidi-override>), ist aber
in der aktuellen Version von FOP noch nicht Implementiert.
Um die Lösung dieses Problems zu finden, wurden die Entwickler von FOP nach der
Implementierung von (<fo:bidi-override>) angesprochen. Es wurde mitgeteilt, dass die
Implementierung dieser Behandlung in der nächsten Version von FOP enthalten wird.
Während des Wartens auf die neue Version wurde nach alternativen Lösungen
geforscht.
1.6.2 Suche nach möglichen Lösungen
Eine der möglichen Lösungen war den FO-Strom nach hebräischen Wörtern zu
untersuchen und die Laufrichtung dieser zu ändern. Um den FO-Strom zu bearbeiten
wurde eine Klasse „TextUmwandlung“ erzeugt. Der Constructor dieser Klasse bekommt
als Übergabeparameter, den in „UTF-8“ Kodierung umgewandelter FO- Stringstrom.
89
In der Klasse „TextUmwandlung“ wurde ein Objekt „bidi“ der Java-Klasse „Bidi“
erzeugt. Dieses Objekt bekommt den FO-Stringstrom und eine Laufrichtung.
bidi = new Bidi(text, Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT)
Diese Java-Klasse implementiert den „Unicode Version 3.0 Bidirectional Algorithm“
[USA#9BA].
Aus dem Objekt „bidi“ wurden alle Levels ausgelesen „byte[] levels = new
byte[bidi.getRunCount()]“, die in dem String vorkommen. Die Ebenen(level) beinhalten
die Information über die Laufrichtung des Strings. Es gilt:
•
level0- der String hat die Laufrichtung von links nach recht „left-to-right“
•
level1- der String hat die Laufrichtung von rechts nach links „right-to-left“
•
level2- der String hat die Laufrichtung von links nach recht „left-to-right“,
beinhaltet aber auch Teilstring mit Laufrichtung von rechts nach links „right-toleft“.
In einer for-Schleife werden alle vorhandene Ebenen durchgegangen und die Teilstrings,
die zu diesen Ebenen gehören, in einen Stringarray gespeichert.
String str = utfText.substring(start, limit);
strings[i] = str;
Die Ebenennummer wird auch in einem Bytearray „levels[i] = (byte)level;“ gespeichert.
Nachdem der String vollständig zerlegt und in einen Array gespeichert wurde, startet die
Methode „reorderVisually“ der Klasse Bidi.
Bidi.reorderVisually(levels, 0, strings, 0, levels.length)
Diese Methode umwandelt diese Teilstrings in die richtige Laufrichtung. Die beinhaltet
folgende Parameter:
•
levels-
Menge von Ebenen die im String vorgekommen waren.
•
LevelStart
Von welcher Ebene soll die Umwandlung starten.
•
Objects
Menge der Teilstrings
•
ObjektStart
Von welchem Teilstring soll die Umwandlung gestartet werden.
•
Count
Die Anzahl von Objekten, die reorganisiert werden sollen.
90
Nach der Reorganisierung, wurden die Teilstrings wieder in einen kompletten String
zusammengeführt.
Bidi bidi = new Bidi(utfText, Bidi.DIRECTION_DEFAULT_RIGHT_TO_LEFT);
byte[] levels = new byte[bidi.getRunCount()];
String[] strings = new String[levels.length];
Bidi lineBidi;
for (int i = 0; i < levels.length; ++i) {
int start = bidi.getRunStart(i);
int limit = bidi.getRunLimit(i);
int level = bidi.getRunLevel(i);
String str = utfText.substring(start, limit);
levels[i] = (byte)level;
strings[i] = str;
}
Bidi.reorderVisually(levels, 0, strings, 0, levels.length);
utfText = "";
for (int i = 0; i < strings.length; ++i) {
utfText = utfText + strings[i];
}
Nach der Reorganisierung wird dieser zusammengeführte String zurück an den
Transformer geliefert. Und die FOP-Methoden transformieren diesen String zu einem
PDF-Dokument.
Diese Lösung hat folgende Ergebnisse gebracht. Die hebräischen Wörter wurden korrekt
dargestellt, allerdings beim Zeilenumbruch passierte folgendes.
„WELT
HALLO“.
Die Laufrichtung von Wörtern selbst war falsch.
So wurde z.B. der Satz auf hebräisch „HALLO WELT“ in einer Zeile richtig dargestellt.
Beim Zeilenumbruch wurde er so dargestellt:
Die Lösung dieses Problems ließ sich nicht mit dem Verändern von String lösen, da man
nicht wusste wann ein Zeilenumbruch vorkommt.
91
1.6.3 Lösung
In der Suche nach der möglichen Lösung des Problems, wurde der Entwickler von
(<fo:bidi-override>) Komponenten für den FOP-Projekt angesprochen. Dieser
Entwickler schickte die FOP-Version mit integrierter Implementierung von (<fo:bidioverride>)
Komponenten.
Das war die Lösung aller Probleme.
Allerdings wurde die Implementierung mit Java1.3 kompiliert. Diese Java-Version hat
in der Klasse „Bidi“ andere Methoden als Java1.4 . Und der ganze Projekt „Hebräische
Typographie im deutschsprachigen Raum“ lief schon mit der neuen Java-Version. Um
das Produkt nicht auf eine bestimmte Java-Version zu begrenzen, wurde einfach die
Klasse „Bidi.java“ von der Java1.3 in die veränderte Version von FOP integriert.
Die Lösung mit der Umwandlung von String brauchte man nicht mehr. Alles was man
brauchte ist das Element „<fo:bidi-override>“ in die XSL-FO-Datei zu platzieren.
Dieses Element wird überall dort platziert, wo eine Textinformation von XML-Datei
kommt.
<fo:block font-family="Arial" font-size="10pt" font-weight="bold" textalign="right">
<fo:bidi-override unicode-bidi="normal">
<xsl:apply-templates select="Name"/>
</fo:bidi-override>
</fo:block>
Nach der Integration von Elementen in die XSL-Dateien, war die Darstellung von allen
Sprachen absolut korrekt.
1.7
Ungelöste Probleme
Zu den ungelösten Problemen Zählt der Zeilenumbruch bei den hebräischen Wörtern.
Dieses Problem kann nur dann gelöst werden, wenn eine „Hypernation“ Datei für die
hebräische Sprache rauskommt. In der „Hypernation“ sind alle Regeln für die jeweilige
Sprache gespeichert.
92
1.8
Letzte Änderungen
Die letzen Änderungen betreffen nur die Layouts von PDF-Dokumenten.
Nach dem Verändern von Schriftzeichenbildern bekommen alle Schriftzeichenbilder
eines Schriftsatzes gleiche Höhe. Die Breite des Schriftzeichenbildes ist nicht festgelegt
und hängt von der Buchstabe ab. Deshalb wurde auch XSL-FO-Dokumente verändert.
Beim Platzieren von Schriftzeichenbildern des Schriftsatzes, bekommen diese eine feste
Höhe.
<fo:external-graphic height="12mm"
Und als letztens wurde das alte Logo (Abbildung 8) im PDF-Dokumenten auf ein neues
Logo (Abbildung 26) ersetzt. Diese wurde später auch für die HTML Seiten
übernommen.
Abbildung 26 Neues Logo
93
2
Ausrichtung von hebräischen
Schriftzeichenbildern
2.1
2.1.1 Einleitung
Die Erstellung von hebräischen Schriftzeichenbildern wurde als zweite Teil der
Diplomarbeit entwickelt. Das Ziel war, die Entwicklung eines Programms für die
Ausrichtung von hebräischen Schriftzeichenbildern.
Jeder Buchstabe eines Alphabetts hat eigene unikale Eigenschaften wie: Breite, Höhe,
Form und Positionierung im Schriftsatz. An einem Beispiel (Abbildung 27) sind die
Größen und die Positionierung von hebräischen Buchstaben im Schriftsatz dargestellt.
Lamed
Endkaf
Jod
obere Grundlinie
obere Dickte
untere Dickte
untere Grundlinie
Abbildung 27 Positionierung
Für die Positionierung werden vier Parameter benötigt: obere Dickte, untere Dickte,
obere Grundlinie und untere Grundlinie. Obere und untere Grundlinien sind für die
eigentliche Positionierung von Buchstaben im Schriftsatz verantwortlich. Die Dickten
bestimmen die Strichstärke des Buchstabens. Ein Buchstabe mit einer standarten Größe
wird zwischen der oberen und der unteren Grundlinien positioniert. In der Abbildung 27
sind keine standarte Buchstaben dargestellt. Der Buchstabe „Lamed“ besitzt eine
Oberlänge, der Buchstabe „Endkaf“ hat eine Unterlänge und der „Jod“ ist der kleinste
94
Buchstabe im ganzen hebräischen Alphabett. Außer Größen, besitzen die Buchstaben
noch „Serifen“. Serifen sind die Endstriche eines Buchstabens, umgangssprachlich auch
„Füßchen“ genannt. Die Ausbildung der Serifen bestimmen im wesentlichen die
Charakteristik und die Ausdruckskraft eines Buchstabens. [LDTWB]
In der Abbildung 28 sind alle Parameter des Buchstabens markiert:
•
a
Breite des Buchstabens
•
b
Höhe des Buchstabens
•
c
untere Dickte
•
d
obere Dickte
•
e
Serifen
Abbildung 28 Buchstabenmasse
95
2.1.2 Problemstellung
Die Schriftzeichenbilder wurden zuerst aus den Büchern mit dem digitalen Fotoapparat
fotografiert und in einem „TIFF“ Format gespeichert. Diese Roh-Bilder wurden zuerst
einzeln bearbeitet. Nach der Bearbeitung waren die TIFF-Bilder sehr Groß (ca.
1000x1500px.). Zusätzlich zu den Schriftzeichenbildern gab’s noch eine Maßdatei.
Anhang dieser Maßdatei konnte man die Originalgröße des Buchstabens ermitteln. Für
die Ermittlung von Originalgrößen, wurde ein Tool entwickelt. Mit diesem Tool hat man
das Schriftzeichenbild vermessen und die Originalgröße des Buchstabens gespeichert.
Nach der Bearbeitung und Vermessung wurden die Schriftzeichenbilder in einem „GIF“
Format gespeichert. Die Erstellung von „GIF“ erfolgte mittels eines Programms, welche
alle Schriftzeichenbilder in die bestimmten Rahmen (60x75px.) reinpresste. Als Folge
wurden die Buchstaben in einer verzerrten Form dargestellt, und die unikale Merkmale
des einzelnen Buchstabens nicht mehr erkennbar waren. Die Positionierung von den
Buchstaben in einem Schriftzeichenbild war auch falsch.
Es musste ein Tool entwickelt werden, um den Schriftzeichenbildern ihre Proportionen
wiederzugeben.
2.1.2 Vorgehensweise
Es
wird
eine
Java-Anwendung
geschrieben,
die
als
Eingabe
vorhandene
Schriftzeichenbilder bekommt und als Ausgabe- die ausgerichteten Schriftzeichenbilder
liefert. Das Ausrichtungsprogramm muss mit den Bildern Arbeiten, deswegen werden
die Bibliotheken für die Bearbeitung von Bildern benötigt. Die Bibliotheken für die
Bildbearbeitung werden im Kapitel 2.3 beschrieben.
Da die vorhandenen Messdaten originale Millimeterwerte des Buchstabens haben,
werden die Schriftzeichenbilder proportional an die Messwerte skaliert. Das Problem
war, dass die „GIF“ Bilder einem Leerraum besaßen. In der Abbildung 29 ist deutlich zu
sehen, dass dieses Schriftzeichenbild ein Freiraum zwischen dem Buchstaben und dem
Bildrand besitzt.
96
Abbildung 29 Schriftzeichenbild(GIF)
Wenn dieses Schriftzeichenbild mit der richtigen Proportion zu den Messwerten von
dem Buchstaben skaliert wird, kommt ein falsches Ergebnis raus. Um es zu vermeiden,
dürfen die Schriftzeichenbilder keine freien Abstände zwischen dem Buchstaben und
dem Bildrand besitzen. Nach dem Skalieren werden die Buchstaben zuerst auf dem
richtigen Platz im Schriftzeichenbild positioniert dann und wieder als GIF gespeichert.
97
2.2 Grundlagen des hebräischen Schriftsatzes
2.2.1 Merkmale der hebräischen Schriftsätze
Merkmale der hebräischen Sprache.
Die hebräische Schrift gehört zu den linksläufigen semitischen Schriften. Sie stellt eine
Weiterentwicklung des kanaanäischen Alphabets, der ältesten Buchstabenschrift
überhaupt, dar und blieb bis heute im wesentlichen unverändert. [EHSKK]
„Die hebräische Schriftsprache gehört der nordischen aramäischen Schriftfamilie an. Sie
ist seit dem 2. Jahrhundert v. der Zeitrechnung von den Juden für Hebräisch verwendet
worden. Als Juden in den verschiedenen Diasporas lebten, begannen sie, die
neuentwickelten Sprachen (darunter z. B. Jiddisch, Ladino, Persisch-Hebräisch)
ebenfalls mit hebräischer Schrift zu schreiben. Die hebräische Schrift entwickelte sich in
drei Hauptarten: die Quadrat, für die Niederschrift der religiösen Texte, die Halbkursive,
für die Erfassung der Liturgie und Kommentarliteratur und die Kursive für den täglichen
Gebrauch. Mehrere Schreibstile sind in der Geschichte von Juden in ihren verschiedenen
Aufenthaltsorten entwickelt worden.“ [Zitat von Dr. Ittai Joseph Tamari].
Die Schriftsprachen, wie Hebräisch und Arabisch, werden horizontal von rechts nach
links geschrieben und gelesen. Die "arabischen" Zahlen (die gewöhnlichen Zahlen,
eigentlich indischer Herkunft), schreibt man jedoch wie üblich von links nach rechts
innerhalb des rechts nach links laufenden Textes.
Das hebräische Alphabet besteht, wie fast alle Alphabete für die semitischen Sprachen,
nur aus Konsonanten. Das Alphabet besteht aus zweiundzwanzig Buchstaben.
Außerdem gibt es noch fünf Buchstaben, die eine bestimmte Endung haben. Die Vokale
werden durch die Punkte oder kleine Striche nur angedeutet. Diese Vokalzeichen stehen
meist unter dem Konsonanten welcher in der Aussprache dem Vokal vorhergeht.
[GIHAB]
Das hebräische Aleph-Bet ist, wie gesagt ein konsonantisches, wenngleich vier der
Buchstaben auch als lange Vokale benutzt werden (Aleph, Hej, Waw, Jud); Da sie das
verständliche und genaue Lesen sehr erleichtern, werden sie mit dem schönen Namen
"Lesemütter" (Imot-Hakri`a) bezeichnet. Außerdem dienen die hebräischen Buchstaben
98
auch als Zahlen: Die ersten neun – für die Einheiten 1-9; die nächsten neun - für die
Zehner (10-90), und die letzten vier - stehen für die Nummern 100, 200, 300 und 400.
[NGPNS]
2.2.2 Merkmale von hebräischen Zeichen
„Die hebräischen Buchstaben waren ursprünglich rein willkürlich-geometrische
Zeichen, während die meist konkreten Buchstaben-Namen als Gedächtnishilfe dienen
sollten. Passend zu der Konsonanten-Schrift, enden die Namen der Buchstaben mit
einem beliebigen Konsonanten, während der Anfangs-Buchstabe des Namens seinen
Laut symbolisiert (akrophonisches Prinzip). Es wird angenommen, dass einige Laute
ihren reinen ursprünglichen Charakter verloren haben (wie z.B. Sin und Samech). Die
Reihenordnung der Buchstaben hat hingegen ihre traditionelle Sequenz bewahrt, die in
einigen Bibelstellen nachzuvollziehen ist (Proverbs 31, 10-31; Psalmen 34,2-23).Die
alten Hebräer und Kana`aniter haben die Menschheit durch dreierlei Gaben bereichert:
"durch den Monotheismus, die Bibel und das Alphabet".“[Prof. Naftali Stern]
Das hebräische Alphabet beinhaltet Buchstaben mit einer standarten Grösse, mit einer
Oberlänge, oder mit einer Unterlänge. Außerdem gibt es auch ein sehr kleiner Buchstabe
„Jod“. Der hebräische Schriftsatz beinhaltet fünf Buchstaben mit einer Unterlänge und
eine Buchstabe mit einer Oberlänge. Alle Buchstaben des hebräischen Schriftsatzes sind
in der Tabelle 3 präsentiert. Diese Tabelle beinhaltet zwei Arten von hebräischen
Schriftsätzen: Quadrat und die Halbkursive.
99
Name des
Buchstabens
Höhe
Kommentare
Quadrat Halbkursiv
(Oberlänge/
Unterlänge)
Alef
Im halbkursiven Schriftsatz ist der
obere Serif sehr stark ausgeprägt,
Standardhö
so dass der Buchstabe in einem
he
Extremfall höher als die Oberlänge
sein kann.
Bet
Standardhö
he
Gimel
Standardhö
he
Dalet
Standardhö
he
Heh
Standardhö
he
Waw
Standardhö
he
Sajin
Standardhö
he
Chet
Standardhö
he
Tet
Standardhö
he
100
Der kleinste
Schriftsatzes
Jod
Kaf
Standardhö
he
Endkaf
Unterlänge
Lamed
Oberlänge
Mem
Standardhö
he
Endmem
Standardhö
he
Nun
Standardhö
he
Endnun
Unterlänge
Ssamech
Standardhö
he
Ajin
Buchstabe
des
Bei manchen quadraten SchriftsätStandardhö
zen besitzt dieser Buchstabe eine
he
Unterlänge.
101
Peh
Standardhö
he
Endpeh
Unterlänge
Zadeh
Standardhö
he
Endzdeh
Unterlänge
Kof
Unterlänge
Resch
Standardhö
he
Shin
Standardhö
he
Taw
Standardhö
he
Tabelle 3 die hebräischen Buchstaben
Die
Schriftzeichenbilder
werden
anhand
von
diesen
Buchstabeneigenschaften
ausgerichtet.
102
2.3
Grundlagen der Bildbearbeitung in JAVA
2.3.1 Ein genereller Überblick der AWT und SWING Klassen
Das Ausrichtungsprogramm wurde in Java geschrieben, deswegen ein Überblick über
die Java Methoden.
Eine Programmiersprache, die zum Ziel hat, plattformunabhängige Softwareentwicklung
zu unterstützen, muss auch eine Bibliothek anbieten, damit sich grafische Oberflächen
gestalten lassen. Die Bibliothek muss im wesentlichen drei Dinge abdecken:
•
Sie muss grafische Primitivoperationen können, wie Linien und Polygone
zeichnen oder Farben und Zeichensätze zuweisen.
•
Sie muss grafische Interaktionskomponenten, die so genannten Widgets
(Window Elements), wie Fenster, Schaltflächen, Textfelder, Menüs und
Container unterstützen.
•
Sie muss ein Modell zur Behandlung der Ereignisse definieren.
Da Java-Programme portabel sein müssen, entsteht schnell das Problem, dass eine tolle
Komponente von einer bestimmten Plattform nicht unterstützt wird und ein anderes
Feature wiederum von einer anderen nicht. Die Bibliothek kann daher nur das
aufnehmen, was auf jeden Fall von jeder grafischen Oberfläche unterstützt wird. Das ist
leider nicht viel. Java definiert dazu das Abstract Window Toolkit (AWT), das
konkrete Plattformen wie Microsoft Windows, Apples MacOS oder Unix mit Motif
implementieren. So wird jede Komponente in Java auf eine Komponente der Plattform
abgebildet. Daher sehen portierte Anwendungen auf jedem Rechner so aus, wie der Rest
der Programme. [JAIEI]
Nach der Freigabe des ersten AWT wurde klar, dass das Leistungsangebot von AWT
nicht für die Zukunft ausreicht. Deshalb wurde eine Erweiterung Namens Java
Foundation Classes „JFC“ erschaffen. Diese Erweiterung besteht im wesentlichem aus:
•
SWING
Unter die Swing-Set-Komponenten fallen ganz neue grafische
Elemente. Diese sind vollständig in Java implementiert. So kann beispielsweise
das Aussehen (engl. look and feel) geändert werden. Der Name „Swing“ war ein
103
Projektname dieser Komponenten und obwohl Swing nur ein Teil der JFC ist,
bleibt der Name für die Oberflächenelemente bestehen.
•
Loock&Feel Dies gibt uns die Möglichkeit, das Aussehen der Komponenten
zur Laufzeit, also ohne das Programm neu zu starten, zu ändern. Alle
Komponenten des Swing-Sets besitzen diese Fähigkeit automatisch.
•
Acsessebility Unterstützung für Menschen mit Behinderungen. Mit dieser API
kann über neuen Interaktionstechniken auf die AWT oder SWINGKomponenten zugegriffen werden. Zu diesen Techniken zählen unter anderem
Lesegeräte für die Blinden, oder Spracherkennung.
•
Java 2D-API Ist eine Technik die über eine Objektbeschreibung Objekte bildet
und diese auf dem Bildschirm darstellt. Mit Hilfe von dieser Bibliothek können
komplexe Objekte durch Pfade gebildet und darauf die Bewegungs- und
Veschiebungsoperatoren angewendet werden.
•
Drag&Drop
Daten können mittels Drag&Drop von einer Applikation zur
anderen übertragen werden. Dabei können auch die Daten übertragen werden,
die nicht aus Java-Programmen stammen.
Die Darstellung von AWT-Komponenten ist schneller als von SWING-Komponenten.
Das liegt daran, das AWT-Komponenten direkt im Fenstersystem über so genannte
Peer-Klassen repräsentiert werden. Die Peer-Klassen sind native Funktionen die auf der
speziellen Benutzeroberfläche implementiert sind. Als Nachteil zeigen die Programmen
unter den verschiedenen Betriebsystemen merkwürdige Seiteneffekte. So kann ein
Textfeld unter Windows weniger als 64K Zeichen aufnehmen, bei den anderen
Oberflächen ist das egal.
Die SWING-Komponenten besitzen keinen Peer. Das heißt die werden nicht direkt in
dem Fenstermodel repräsentiert. Die vollständige Ereignisbehandlung wird von Java
übernommen und die Komponenten werden mit primitiven Zeichenoperationen gemalt.
[JAIEI]
Das Ausrichtungsprogramm wird mit Hilfe SWING-Komponenten geschrieben. Obwohl
die Darstellung langsamer ist, kann man sicher sein, dass keine Seiteneffekten auftreten.
104
2.3.2 JIMI
Diese Bibliothek ist reine Java Klassenbibliothek, die hauptsächlich Lade- und
Speicheroutinen für Bilder zu Verfügung stellt. JIMI stellt die Möglichkeit zur Anzeige
bereit, um sehr große Grafiken speichersparend zu verwalten. So wird nur ein Bildteil im
Speicher gehalten, der gerade sichtbar ist. Für die Speicherverwaltung stellt JIMI ein
eigenes Speicherverwaltungssystem VMM (Virtual Memory Management) bereit,
ebenso gibt es ein eigene Image Klasse, die schnelleren Zugriff auf die Pixelwerte
erlaubt. Zusätzlich gibt es einpaar Filtern für die Rotation und Helligkeitsanpassung, die
auf AWT- und JIMI-Image arbeiten.
JIMI unterstützt unter anderem folgende Formate: BMP, GIF nicht komprimierend,
JPEG, TIFF, PNG, PSD. Nicht für alle Formate gibt es gleichfalls Dekodierer und
Kodierer. Manche Dekodierer und Kodierer befinden sich im JAI (Java Advanced
Imaging).
So kann JIMI-Bibliothek alle diese Formate auslesen aber nicht in allen diesen Formaten
speichern. Für die GIF und TIFF Formate gibt es keine Kodierer.
Beispiel: (Eine BMP Datei auslesen und in verschiedenen Formaten speichern)
import java.awt.*;
import java.awt.image.*;
import com.sun.jimi.core.Jimi;
import com.sun.jimi.core.JimiException;
import com.sun.jimi.core.JimiRasterImage;
public class JimiBeispiel
{
public static void main( String args[] ) throws Exception {
//Bild in einen Image auslesen
Image image = Jimi.getImage("test.bmp");
//Das Image als ein Bild speichern
String mimes[] = { "bmp","png","psd"};
// "jpg" funktioniert so nicht.
// für „gif“, „tiff“ gibt es keinen Kodierer
for ( int i=0; i<mimes.length; i++ ){
String mime = "image/"+mimes[i];
String filename = "JimiTest." + mimes[i];
Jimi.putImage( mime, image, filename );
}
105
System.exit(0);
}
}
Da die Jimi-Bibliothek hauptsächlich für das Laden und Speichern von Bildern
entwickelt wurde, bietet die wenig Möglichkeiten Bilder zu bearbeiten. Diese
Mechanismen bietet eine andere Java-Bibilothek JAI (Java Advanced Imaging)
2.3.3 JAI
Die Java Advanced Imaging Software ist heute eine ausgereifte Technologie, die nicht
nur von maßgeblichen Bildagenturen, sondern auch in den Bereichen E-Commerce,
Fotoverarbeitung und Dokumentbearbeitung sowie in technischen Märkten eingesetzt
wird. Sie beschleunigt sowohl die Entwicklung als auch den produktiven Einsatz in der
Java Software-Umgebung und ermöglicht die Entwicklung plattformunabhängiger
Produkte. Zudem lassen sich Softwareprodukte um vollkommen neue Fähigkeiten für
die Bearbeitung digitaler Bilder erweitern. [PM2001]
Die Java Advanced Imaging API wurde von Autometric, Sun, Eastman Kodak und
Siemens definiert und bietet Bildbearbeitungsfunktionen, die noch über die Fähigkeiten
von Java 2D hinausgehen und diese stark erweitern. So bietet die Advanced Imaging
API Methoden, die in Anzahl und Funktionsumfang stark an Programme, wie z.B.
Adobe Photoshop erinnern.
Die
Fähigkeiten
dieser
API
reichen
von
Bildteilungsfunktionen
bis
zur
Frequenzmanipulation der Bilder.
Die API wurde auf spezielle Bedürfnisse zugeschnitten - z.B. für Anwendungen der
Medizin (So kann man beispielsweise auf zu dunklen Röntgenbildern mehr erkennen,
indem man den Farbbereich streckt; Die dunkelste Farbe wird dazu auf schwarz, die
hellste Farbe auf weiß gesetzt).
Sie bietet 39 pixelweise Operatoren, 13 Flächenoperatoren, ca. 20 bildorientierte
Operatoren. Unter anderem werden folgende die Bildformate unterstützt: BMP, GIF,
JPEG, PNG, PNM, TIFF. Die unterstützte Bildkompressionsverfahren: TIFF, G3, G4,
LZW. [MSIJM]
106
Beispiel: Das Beispiel zu den arithmetischen Operationen verwendet 2 Bilder als
Quellen, um ein drittes resultierendes Bild zu erzeugen. Das obere farbige Bild wird mit
dem unteren Graustufen-Bild kombiniert. Das untere Graustufen-Bild wirkt wie eine
Maske auf dem oberen Bild.
import java.awt.*;
import java.io.
import com.sun.media.jai.codec.*;
import javax.media.jai.*;
public class JAIBeispiel{
public static void main( String args[] ) throws Exception {
PlanarImage src1 = JAI.create("fileload", "lincoln.jpg");
PlanarImage src2 = JAI.create("fileload", "mask.gif");
// alter mask image a bit
Byte[] bandValues = new Byte[3];
bandValues[0] = new Byte((byte)2);
ParameterBlock pb = new ParameterBlock();
pb.add((float)src2.getWidth());
pb.add((float)src2.getHeight());
pb.add(bandValues);
PlanarImage temp = JAI.create("constant", pb, null);
pb = new ParameterBlock();
pb.addSource(src2);
pb.addSource(temp);
src2 = JAI.create("add", pb, null);
//Add Operator
pb.addSource(src1);
pb.addSource(src2);
PlanarImage target = JAI.create("add", pb1, null);
System.exit(0);
}
}
Bei der Addition zweier Bilder werden die Werte an der Stelle 0,0 des Ausgangsbildes
mit den Werten an der Stelle 0,0 des anderen Ausgangsbildes addiert und das Resultat
wird an der Stelle 0,0 des resultierenden Bildes gespeichert. Dieser Vorgang wird für
107
jedes Pixel des Bildes durchgeführt. Das Ergebnis wird in der Abbildung 30 gezeigt.
[JAITUT]
Abbildung 30 Addition
2.3.4 GIFEncoder
Java bietet als nette Hilfe das Laden von GIF-kodierten Grafiken an. Leider blieben
Routinen zum Speichern in dem Dateityp auf der Strecke. Doch ist das Laden von GIFDateien überhaupt gestattet? Da UNISYS das Patent auf den Kompressionsalgorithmus
Welch-LZW für GIF-Dateien hält, ist es eine rechtliche Frage, ob wir UNISYS Geld für
das Laden von GIF-Dateien zum Beispiel aus Applets bezahlen müssen. Auf die an
UNISYS gestellte Frage “If I make an applet (for profit) which loads a GIF image using
the Java API function, will I need a license from you?” antwortet Cheryl D. Tarter von
UNISYS: “Yes, you need a license from Unisys.” Das heißt im Klartext, dass eigentlich
alle bezahlen müssten. Eine weitere Anfrage an die für Lizenzen zuständige Stelle
bestätigte dies. Mit einer Klage seitens UNISYS ist jedoch nicht zu rechnen und beim
Lesen von GIF-Dateien ist somit keine Gefahr zu erwarten. Wer jedoch Bibliotheken
zum Schreiben von LZW-komprimierten GIF-Dateien anbietet, sollte vorsichtig sein.
Der Patentinhaber ist im Jahr 2000 dazu übergegangen, von Betreibern von Webseiten
pauschal 5.000 Dollar Lizenzgebühren einzufordern, wenn sie nicht nachweisen können,
dass die verwendeten GIF-Grafiken mit lizenzierter Software erstellt wurden. Eine
Webseite zu diesem Thema findet sich unter http://burnallgifs.org/ (den 01.12.03).
[JAIEI]
Um Problemen mit den Lizenzen aus dem Weg zu gehen, hat Sun gleich die Finger von
einer GIF-siecheren Routine gelassen. Um dennoch ohne zusätzliche Bibliotheken eine
GIF-Datei im GIF87a Format non-interlaced zu sichern, hat Adam Doppelt (E-Mail:
108
amd@marimba.com) die Klasse GIFEncoder geschrieben, die es gestattet, beliebige
Image-Objekte oder Bytefelder zu speichern. Die Klasse liegt zum Beispiel unter
http://www.gurge.com/amd/old/java/GIFEncoder/index.html (den 01.12.03).
Um GIF-Daten zu Erstellen, wird ein Exemplar der GIFEncoder-Klasse angelegt. Die
Klasse besitzt zwei Constructoren. Man kann entweder ein geladenes Image-Objekt an
den Constructor schicken oder drei Felder mit den RGB-Werten. Über die Write()Methode der Klasse wird die Datei dann in einen Ausgabestrom geschrieben. Dieser
sollte gepuffert sein, da die Kodierung ohnehin schon lange genug dauert. Im folgendem
Beispiel wird dies gezeigt:
GIFEncoder encode = new GIFEncoder( image );
OutputStream out = new BufferedOutputStream(new FileOutputStream("DATEI"));
encode.Write( out );
Da beim herkömmlichen GIF-Format die Bilder nicht mehr als 256 Farben besitzen
können, müssen 24-Bit-Grafiken umgewandelt werden. Hier wird ein QuantizationAlgorithmus verwendet. Eine Referenz auf diesen Algorithmus ist auf der Webseite von
Adam Doppelt zu finden. [ JAIEI]
Beispiel: (ein Bild auslesen und als GIF speichern)
import java.awt.*;
import java.io.*;
import java.net.*;
import javax.swing.*;
public class giftest extends JFrame{
public static void main(String args[]) throws Exception {
// Das Bild Laden
Image image = this.getToolkit().getImage("bild.jpg");
MediaTracker tracker = new MediaTracker(this);
tracker.addImage(image,0);
try{
tracker.waitForID(0);
}
catch (InterruptedException e){
System.out.println("das Bild konnte nicht geladen werden");
}
// Image als GIF kodieren
GIFEncoder encode = new GIFEncoder(image);
OutputStream out = new BufferedOutputStream(
new FileOutputStream("bild.gif"));
109
encode.Write(out);
System.exit(0);
}
}
In dem Forschungsprojekt wurden alle GIF-Bilder mit einem lizenzierten Programm
erstellt. Da die aber falsche Parameter besassen, mussten die verändert werden und neu
im GIF Format gespeichert. Deshalb wurde entschieden diese GIFEncoder-Klasse zu
benutzen.
110
2.5 Entwicklung des halbautomatischen
Ausrichtungsverfahrens
2.5.1 Lösungsweg
Automatische Ausrichtung
Die Idee war die Höhe der Bilder für alle Buchstaben gleichzusetzen und die Buchstaben
in diese Bilder an die richtige Position zu platzieren. Die Höhe des einzelnen Bildes
muss genau so groß sein wie die mittlere Höhe des Buchstabens mit Standartgröße plus
die Oberlänge und die größte Unterlänge.
Die Oberlänge ist der Abstand von der oberen Grenze des größten Buchstabens
„Lamed“ bis zu oberen Grundlinie.
Die Unterlänge ist der Abstand von der unteren Grenze des größten Buchstabens mit
der Unterlänge bis zu der unteren Grundlinie.
Oberlänge
Unterlänge
Abbildung 31 Auswahl der Ober- und Unterlänge
Die Schriftzeichenbilder im GIF Format werden aus der Datenbank ausgelesen. Es bleibt
aber unbekannt welches Schriftzeichenbild die größte Unterlänge hat und wie groß die
Oberlänge ist. Um diese Werte auszurechnen werden Originalgrößen der Buchstaben
benötigt. Diese Originalgrößen werden ebenfalls aus der Datenbank ausgelesen.
Die Originalgrößen wurden mittels Vermessungsprogramms ermittelt und stellen die
exakten Größen des Buchstabens in Millimeter dar.
So ist es möglich die Höhe für die Schriftzeichenbilder auszurechnen.
111
Ein weiteres Problem stellen die GIF-Bilder dar, die aus der Datenbank ausgelesen
werden. Alle GIF-Bilder besitzen gleiche Breite und Höhe. Das bedeutet, dass die
Buchstaben im Schriftzeichenbild einen weißen Rand oben, unten und an den Seiten
haben. Deshalb müssen die Buchstaben aus dem Schriftzeichenbild extrahiert und in ein
neues Bild mit der Größe des Buchstabens eingefügt werden. Dafür wird jedes Bild auf
seine Pixelwerte geprüft. Sobald die Pixelwerte des Buchstabens auftauchen, bricht der
Überprüfungsvorgang auf. Die Abbildung der Buchstabe wird aus dem Bild extrahiert
und in ein neues Bild platziert. So beinhaltet dieses neues Bild nur den Buchstaben
selbst ohne jegliche Ränder.
Um die Bilder auszurichten reicht der Millemeterwert nicht aus. Dazu braucht man einen
Pixelwert.
Die Bilder müssen an eine angemessene Pixelgröße angebracht werden. Dafür wird die
Höhe jedes Bildes durch seine Millimeterhöhe dividiert. Man bekommt die
proportionale Anzahl der Pixel in einem Millimeter für dieses Bild. Dieser Wert wird für
alle Schriftzeichenbilder ausgerechnet und davon kleinste genommen. So wird
vermieden, dass der Pixel/Millimeter Wert von einem verzerrten Bild genommen wird.
Nachdem Ausrechnen des Pixel/Millimeterwertes, wird die neue Höhe für die
Schriftzeichenbilder in Millimeter ermittelt und in den Pixelwert umgewandelt. (mittlere
Millimeterhöhe des Buchstabens mit der Standarthöhe plus + Millimeterhöhe der
Oberlänge aus dem „Lamed“ + Millimeterhöhe der größten Unterlänge) * kleinste
Pixel/Millimeterwert.
Es wurde eine mittlere Bildhöhe gefunden. Die einzelnen Buchstaben werden dann in
dieses Bild an die richtige Position platziert. Das Problem ist, dass jedes Bild was
ausgelesen wurde ein eigener Pixel/mm. Wert besitzt. Um die Bilder, in dem neuen
Schriftzeichenbild, richtig zu platzieren, müssen Schriftzeichenbilder mit den
Buchstaben zuerst auf den festgelegten kleinsten Pixel/Millimeterwert gesetzt werden.
Die Größen für die Bilder mit den Buchstaben werden wie folgt ausgerechnet:
Bildhöhe für den Buchstaben mit Oberlänge
(Millimeterhöhe des Buchstabens „Lamed“ aus der Datenbank * kleinste
112
Bildhöhe für den Buchstaben mit der Standarthöhe
(mittlere Millimeterhöhe des Buchstabens mit der Standarthöhe * kleinste
Bildhöhe des Buchstabens mit der Unterlänge
(größte Millimeterhöhe des Buchstabens mit einer Unterlänge * kleinste
Nach dem Ausrechen der Pixelhöhen für die Buchstaben, werden die Bilder mit diesen
Buchstaben auf ausgerechnete Werte skaliert.
So bekommen alle Buchstaben in den Bildern richtige Proportionen. Die Buchstaben
werden nur noch an die richtigen Positionen in die Schriftzeichenbilder gebracht.
Es wird ein neues Schriftzeichenbild mit der festgelegten Höhe und der Breite von
auszurichtendem Bild erzeuget.
Das Bild wird in dieses Schriftzeichenbild an die Position mit den folgenden
Koordinaten positioniert:
X=0
Y = Oberlänge(ausgenommen „Lamed“ Y = 0)
Alle ausgerichteten Schriftzeichenbilder werden in einem Fenster, der Reihe nach
angezeigt.
Manuelle Nachbearbeitung
Die Buchstaben des Alphabets haben so genannte „Serifen“, die außerhalb von oberen
bzw. unteren Grundlinie liegen. Deswegen wird eine Möglichkeit zu manueller
Korrektur benötigt.
Jedes Schriftzeichenbild was im Fenster dargestellt wird, befindet sich in einem
„Kasten“. Dieser „Kasten“ hat die gleiche Grösse, wie das Schriftzeichenbild. Innerhalb
dieses Kastens kann man dieses Bild mit der Maus freibewegen. So wird der Buchstabe
innerhalb dieses Kastens an die richtige Position gebracht. Das Schriftzeichenbild wird
dann mit der veränderten Position des Bildes gespeichert.
113
Manche Bilder werden trotz der automatischen Skalierung nicht richtig dargestellt. Das
hängt wiederum von den „Serifen“ ab. In diesem Fall kann die Grösse des Bildes
geändert werden. Dafür gibt es einen Skalierungsbalken, womit das aktuelle Bild
proportional verkleinert oder vergrößert werden kann.
So wird der Schriftsatz in zwei Schritten (automatische Ausrichtung und manuelle
Nachbearbeitung) ausgerichtet.
2.5.2 Entwicklung des Ausrichtungsprogramms
Die Schriftzeichenbilder im GIF Format werden aus der Datenbank ausgelesen. Dafür
wird eine Verbindung zu der Datenbank hergestellt.
verbindung = DBVerbindung.loginPlus2("hebrewtype", "hebrewtype");
Alle Schriftsätze werden aus der Datenbank ausgelesen.
Schriftsatz[] schriftsaetze =
SchriftsatzMenge.createMenge().getSchriftsaetze();
Es wird der erste von der Datenbank zurückgegebene Schriftsatz genommen. Die
Methode „schriftsaetzeLaden“ wird aufgerufen. Diese enthält als Parameter den
aktuellen Schriftsatz.
schriftsaetzeLaden(schriftsaetze[i]);
Wobei Index „i“ gleich Null ist.
In dieser Methode werden alle Drucktypen von diesem Schriftsatz ausgelesen.
DruckType[] buchstaben = schriftsatz.druckTypen();
Die Drucktypen beinhalten alle Eigenschaften des einzelnen Buchstabens, wie kleine
und große GIF-Bilder, die Messdaten, vektorisierte Bilder.
In dem Ausrichtungsprogramm werden nur die kleinen Bilder ausgerichtet. Diese
ausgelesenen Schriftzeichenbilder werden als Objekte der Klasse Buchstabe gespeichert.
Dafür wird ein Array von Objekten dieser Klasse erzeugt. Das hebräische Alphabett
beinhaltet 27 Buchstaben, so beinhaltet das Array auch 27 Objekte.
Buchstabe[] buchstabe = new Buchstabe[27];
Zu einem Schriftsatz gehören nicht nur die Buchstaben des Alphabetts, sondern auch die
Sonderzeichen, die nicht ausgerichtet werden müssen. Deshalb werden alle Drucktypen
114
nach der Kategorie abgefragt. Wenn eine Drucktype zu der Kategorie „Buchstabe“
gehört, wird es weiter verarbeitet.
for(int a = 0; a< buchstaben.length;a++){
String zeichenKategorie = buchstaben[a].getKategorie();
if(zeichenKategorie.equals("Buchstabe")){
Die Buchstabeneigenschaften werden ausgelesen. Dabei wird zwischen verschiedenen
Buchstabentypen unterschieden: Buchstabe mit Oberlänge, Buchstaben mit der
Unterlänge und Buchstaben mit einer Standarthöhe. So kann man später anhand von
ausgelesenen Parametern die Oberlänge, Unterlänge und mittlere Standarthöhe
ermitteln.
Wenn das Schriftzeichenbild von diesem Buchstaben existiert, und die Messdaten
vorhanden sind, wird die Millimeterhöhe des Buchstabens ausgelesen.
Es gibt nur einen Buchstaben mit der Oberlänge „Lamed“. Die Höhe des Buchstabens
wird in die Variable Oberlänge gespeichert.
if(buchstaben[a].name().equals("lamed")){
if (buchstaben[a].messung() != null){
//Millimeterhöhe des Buchstabens
Oberlaenge = buchstaben[a].messung().hoehe();
Mit einer Unterlänge gibt es fünf Buchstaben: „Kof“, „Endzadeh“, „Endpeh“, „Endnun“,
„Endkaf“. Dabei wird der Buchstabe mit der größten Millimeterhöhe ermittelt. Dieser
Wert wird in die Variable Unterlänge gespeichert.
if(buchstaben[a].name().equals("endkaf")){
if (buchstaben[a].messung()!= null){
if(Unterlaenge < buchstaben[a].messung().hoehe()){
Unterlaenge = buchstaben[a].messung().hoehe();
Für den kleinsten Buchstaben „Jod“ wird der kleinste Buchstabenwert ermittelt. Dieser
wird in der Variable „KleinsteWert“ gespeichert.
if(buchstaben[a].name().equals("jod")){
if (buchstaben[a].messung()!=null){
KleinsteWert = buchstaben[a].messung().hoehe();
Für die restlichen Buchstaben wird, aus kleinster und größter Standarthöhe, die
Standardhöhe ermittelt. Kleinste und die Größte Höhen werden in entsprechende
Variablen, MinStandardwert, MaxStandardwert gespeichert.
115
if(buchstaben[a].name().equals("schin") ||
buchstaben[a].name().equals("shin") ){
if (buchstaben[a].messung()!=null){
if(MaxStandardwert < buchstaben[a].messung().hoehe())
MaxStandardwert = buchstaben[a].messung().hoehe();
if(MinStandardwert > buchstaben[a].messung().hoehe())
MinStandardwert = buchstaben[a].messung().hoehe();
Nach dem Auslesen und speichern von Messhöhen in die entsprechende Variablen, wird
das auszurichtende GIF-Bild verarbeitet. Da die Bilder um den Buchstaben herum noch
einen weißen Rand besitzen, muss dieser entfernt werden. Dies geschieht in der Klasse
Buchstabe.
Für jede Drucktype wird ein Objekt der Klasse Buchstabe erzeugt. Dabei wird auch auf
die Positionierung von dem Buchstaben im Alphabett geachtet. So werden die
Schriftzeichenbilder im Programm alphabetisch dargestellt. Beim Erzeugen von dem
Objekt wird, als Parameter, die Drucktype des jeweiligen Buchstabens übergeben.
//Ein Objekt der Klasse Buchstabe erzeugen
buchstabe[12] = new Buchstabe(buchstaben[a]);
Die Bearbeitung von dem Bild
Im Constructor werden der Buchstabenname und die Millimeterhöhe gespeichert und die
Methode „zuschneiden()“ mit der Drucktype als Parameter aufgerufen.
public Buchstabe(DruckType b) {
this.buchstabeName = b.name();
this.messungHoehe = b.messung().hoehe();
zuschneiden(b);
}
In der Methode zuschneiden wird zuerst das kleine Bild aus dem Drucktype-Objekt
ausgelesen und als Bytearray in einem Image gespeichert.
Aufnahme bildKlein = b.bildKlein();
byte[] daten = bildKlein.daten();
image_in = new ImageIcon(daten).getImage();
Um den weißen Rand aus dem Bild zu entfernen müssen die RGB-Werte aller Pixel des
Images analysiert werden. Es wird ein neues PixelGraber-Objekt (pg) erzeugt, welches
die RGB-Farben aus dem Image in einen Array (pixelArray) speichert. Dem Objekt
werden folgende Parameter übergeben: ein Image (image_in) und ein Bereich auf dem
Image (0, 0, istBreite, istHoehe), aus dem die RGB-Werte ausgelesen werden. Die
116
letzten zwei Parameter bestimmen die Rheinfolge, in der die RGB-Werte in das Array
gespeichert werden. Die Farben für einen Punkt (i,j) sind im Array an der Position (j – x)
* istBreite + (i – y) + 0 gespeichert.
Das Auslesen der Farbwerte wird durch die Funktion grabPixels() initiiert. So füllt
„pg.grabPixels();“ das Array mit den Farbwerten.
istBreite = image_in.getWidth(this);
istHoehe = image_in.getHeight(this);
//ein Pixelarray erstellen
pixelArray = new int[istBreite*istHoehe];
//Das Bild zerlegen
pg = new
PixelGrabber(image_in,0,0,istBreite,istHoehe,pixelArray,0,istBreite);
//Pixelarray mit Werten füllen
try{
pg.grabPixels();
}
catch(InterruptedException e){
System.err.println( "PixelGrabber1--Error getting pixels" );
}
Nachdem die RGB-Werte in das Array „pixelArray“ gespeichert wurden, werden die
RGB-Werte einzelner Pixel miteinander verglichen. Zuerst wird der Pixel rechts unten
als Anfangswert genommen.
x = istBreite -1;
y = istHoehe;
pixel0 = pixelArray[(y - 1) * istBreite + x];
Die Farben sind durch die Grundfarben Rot, Grün und Blau in den Abstufungen 0 bis
255 gegeben. Sie setzen sich zu einer 24-Bit-Zahl ,die den Farbwert repräsentiert,
zusammen. Jede Farbe hat eine eigene Position. [JAIEI]
Die RGB-Werte werden ausgelesen.
rot0 = (pixel0 >> 16) & 0xff;
gruen0 = (pixel0 >> 8) & 0xff;
blau0 = (pixel0) & 0xff;
Jetzt werden alle Pixel aus dem Array ausgelesen und die RGB-Werte von diesen Pixel
mit den Anfangswerten verglichen.
117
Wenn die RGB-Werte des aktuellen Pixels nicht mit den Anfangswerten übereinstimmt
„if(rot!=rot0 || gruen!=gruen0 || blau!=blau0)“, werden die aktuellen Koordinaten des
Punktes gespeichert „hoehe2 = y;“.
//Von oben nach unten
x = istBreite-1;
y = 0;
do {
y++;
for(x=istBreite-1;x>=0;x--) {
pixel = pixelArray[y * istBreite + x];
rot
= (pixel >> 16) & 0xff;
gruen = (pixel >> 8) & 0xff;
blau
= (pixel)
&
0xff;
if(rot!=rot0 || gruen!=gruen0 || blau!=blau0) {
hoehe2 = y;
break;
}
}
}
while(y<istHoehe && rot==rot0 && gruen==gruen0 && blau==blau0);
Die Untersuchung der Pixel verläuft in vier Schritten: von oben nach unten, von unten
nach oben, von rechts nach links und von links nach rechts. So werden nicht alle Werte
untersucht, sondern nur die Randwerte. Im Endeffekt bekommt man vier Koordinaten,
bei denen die RGB-Werte des Pixels mit den Anfangswerten nicht übereinstimmen:
•
„hoehe1“- die untere y-Koordinate
•
„hoehe2“- die obere y-Koordinate
•
„breite1“- die rechte x-Koordinate
•
„breite2“- die linke x-Koordinate
Aus diesen Koordinaten kann die Größe des neuen Bildes bestimmt werden.
hoehe = hoehe1 - hoehe2;
breite = breite1 - breite2;
In der Abbildung 32 sind alle Koordinaten sowie die Größe von neuem Image gezeigt.
118
breite2 X
0,0 breite1
hoehe2
hoehe
hoehe1
breite
Y
Abbildung 32 Ausschneiden
Nachdem die Grenzkoordinaten und die Größe für das neue Image ermittelt wurden,
kann ein neues Image erzeugt werden. Dafür wird ein neues PixelGraber-Objekt (pg)
erzeugt, der die RGB-Werte von dem entstandenen Rechteck (in der Abbildung 32 rotes
Rechteck mit dem Buchstaben) in ein Array speichert. Um ein neues Image zu erzeugen,
wird die Klasse MemoryImageSource() aufgerufen. Diese Klasse produziert
Bildinformationen aus einem Array von Pixels. Diese Klasse wird mit den folgenden
Parametern aufgerufen: „breite“ und „hoehe“ (bestimmen die Grösse von neuem Image),
„pixelArray“ (Array aus dem die RGB-Werte ausgelesen werden) und die letzte zwei
Parametern (bestimmen die Rheienfolge in der die RGB-Werte ausgelesen werden). Die
Farben für einen Punkt (i,j) werden aus dem Array von der Position (j – x) * istBreite +
(i – y) + 0 ausgelesen.
pixelArray_out = new int[breite*hoehe];
pg = new
PixelGrabber(image_in,breite2,hoehe2,breite,hoehe,pixelArray_out,0,breite);
try{
pg.grabPixels();
}
catch(InterruptedException e){
System.err.println( "PixelGrabber1--Error getting pixels" );
119
}
//Erzeugen neues Bild
this.bild = createImage(new MemoryImageSource(breite, hoehe, pixelArray_out,
0, breite));
Als Ergebnis bekommt man das Bild, was nur den Buchstaben beinhaltet Abbildung 33.
Abbildung 33 das Bild vor und nach der Verarbeitung
Nach der Verarbeitung des Bildes wird die Proportion zwischen der Höhe des Bildes in
Pixel und der Millimeterhöhe (Pixel/Millimeterwert) ermittelt. Die Höhe des Bildes wird
aus dem Objekt „buchstabe[12]“ ausgelesen „buchstabe[12].getHoehe();“.Die Variable
„mmWert“ wurde global definiert „private int mmWert = 100“, so dass beim
Ausrechnen von Millimeterwerten von allen Buchstaben der kleinste Wert ermittelt
werden kann.
pxHoehe = buchstabe[12].getHoehe();
//mmWert
if(mmWert > pxHoehe/buchstaben[a].messung().hoehe())
mmWert = pxHoehe/buchstaben[a].messung().hoehe();
So werden alle Schriftzeichenbilder überprüft und der kleinste Pixel/Millimeterwert
genommen.
Nach der Verarbeitung aller Schriftzeichenbilder müssen die einzelnen Höhen in
Millimeter ermittelt werden. So wird die Standardhöhe, durch ein Mittelwert aus den
maximalen und minimalen Standardhöhen, ermittelt. Die Oberlänge ergibt sich aus dem
Unterschied zwischen der Oberlängehöhe und der mittleren Standardhöhe. Die
Unterlänge wird durch substrahieren der Standardhöhe von der Unterlängehöhe
berechnet.
//Standartwert ermitteln
Standardwert = (MinStandardwert + MaxStandardwert)/2;
120
//Obere Schnitt ermitteln
obereSchnitt = Oberlaenge - Standardwert;
//Untere Schnitt ermitteln
untereSchnitt = Unterlaenge - Standardwert;
Nach dem Ausrechnen des Pixel/Millimeterwertes, wird eine neue Höhe für die
Schriftzeichenbilder in Millimeter ermittelt und in den Pixelwert umgewandelt. (mittlere
Millimeterhöhe des Buchstabens mit der Standarthöhe plus + Millimeterhöhe der
Oberlänge aus dem „Lamed“ + Millimeterhöhe der größten Unterlänge) * kleinste
Pixel/Millimeterwert. Außer allgemeiner Bildhöhe werden die Höhen für jeden
Buchstabentyp erstellt. Diese Höhen werden beim skalieren der Schriftzeichenbilder
benötigt. Der Skalierungsvorgang wird benötigt, da beim Erstellen von GIF-Bildern
wurden manche Bilder verzerrt gespeichert.
//Neue gesamte Imagegroesse ermitteln (in Pixel umwandeln)
ImageGroesse = (untereSchnitt + Standardwert + obereSchnitt) * mmWert;
//Imagegroesse fuer Oberlaenge
OberlaengeImageGroesse = (Standardwert + obereSchnitt) * mmWert;
//Imagegroesse fuer die Unterlaenge
UnterlaengeImageGroesse = (untereSchnitt + Standardwert) * mmWert;
//Imagegroesse fuer die Standartbuchstabe
StandartImageGroesse = (Standardwert) * mmWert;
//Imagegroesse fuer den kleinsten Standartwert
KleinsteImageGroesse = KleinsteWert * mmWert;
Die Bilder werden auf die definierten Größe skaliert und ausgerichtet. So werden alle
Bilder, je nach dem Buchstabentyp, festgelegte Höhen bekommen. Das heißt die
Buchstaben eines Typs werden gleich hoch dargestellt. Die Bilder werden aus den
Objekten der Klasse Buchstabe in einer for-Schleife ausgelesen. Vor dem Auslesen der
Bilder wird überprüft, ob dieses Bild existiert. Ein Array von Objekten der Klasse
Buchstabe wurde für alle siebenundzwanzig Schriftzeichenbilder angelegt, es kann aber
vorkommen, dass der Schriftsatz nicht alle Schriftzeichenbilder beinhaltet.
for(int j = 0;j<buchstabe.length; j++){
if(buchstabe[j] != null){
Die
Schriftzeichenbilder
werden
je
nach
Buchstabentyp
behandelt.
Das
Schriftzeichenbild wird beim skalieren proportional auf die vordefinierte Höhe gebracht.
So zum Beispiel wird das Schriftzeichenbild des Buchstabens „Lamed“ auf die Größe
„OberlaengeImageGroesse“ gebracht.
121
//Oberlaenge
if (buchstabe[j].getBuchstabeName().equals("lamed")){
//Buchstabe skalieren
pxHoehe = buchstabe[12].getHoehe();
prozentY = (pxHoehe * 100)/OberlaengeImageGroesse;
Für die Skalierung eines Bildes wird ein neues Objekt „skalieren“ der Klasse
„Skalieren()“ erzeugt. Dabei werden zwei Parameter an den Constructor übergeben: der
Skalierungfaktor „prozentY“ und Buchstabenobjekt „buchstabe[12]“.
skalieren = new Skalieren((int)prozentY, buchstabe[12]);
Beim Erzeugen von dem Objekt „skalieren“ wird die Methode „getScaledInstance()“ an
das Objekt „bild = buchstabe[12].getBild()“ angewendet.
Image skaliert = bild.getScaledInstance(imageBreite, imageHoehe,
Image.SCALE_SMOOTH);
Diese Methode der Klasse „Image“ gibt ein neues Image-Objekt mit veränderten
Ausmaßen zurück. Beim Aufrufen der Methode „getScaledInstance()“ wird der
Skalierungsparameter „Image.SCALE_SMOOTH“ verwendet. Dieser Parameter gibt an,
dass ein Algorithmus verwendet wird, der mehr Wert auf gute Bildqualität legt und
weniger auf Geschwindigkeit. Nach der Skalierung des Bildes, wird das Bild im Objekt
„buchstabe[12]“ mit dem skalierten überschrieben. Die aktuelle Höhe und Breite werden
auch im Objekt gespeichert.
//Werte ueberschreiben
buchstabe[12].setBild(skalieren.getSkaliert());
buchstabe[12].setBreite(skalieren.getBreite());
buchstabe[12].setHoehe(skalieren.getHoehe());
Nach der Skalierung kann das Schriftzeichenbild endlich ausgerichtet werden. Es wird
eine Methode „ausrichten(j,o_schnitt)“aufgerufen. Der Parameter „j“, ist die Nummer
von dem Objekt, das das auszurichtete Schriftzeichenbild beinhaltet, und der Parameter
„o_schnitt“ bestimmt, wie groß der Abstand von der oberen Grenze des neuen Bildes bis
zu Buchstabe sein soll. Für den „Lamed“ ist dieser Wert gleich null, da dieser Buchstabe
eine Oberlänge besitzt.
o_schnitt = 0;
Für alle anderen Buchstaben des Schriftsatzes ist dieser Parameter gleich Oberlänge mal
Pixel/Millimeterwert:
o_schnitt = (int)(obereSchnitt * mmWert);
122
//Buchstabe ausrichten
buchstabe[j].setAusgerichtetesBild(ausrichten(j,o_schnitt));
In der Methode „ausrichten()“ wird ein neues Image „ausgerichteteImage“, mit der
vordefinierten Höhe „(int)(ImageGroesse)“ und der Breite von aktuellem Bild „width +
10“, erstellt. Über die Grafikskomponente „Graphics g“ wird der Hintergrund von
diesem Image auf weiß gesetzt „ g.setColor(); g.fillRect();“. Und anschließend wird in
dieses neue Image das alte Schriftzeichenbild aus dem Objekt „buchstabe[nummer]“
platziert „g.drawImage();“.
public Image ausrichten(int nummer, int o_schnitt){
//Image aus dem Array auslesen
int width = buchstabe[nummer].getBreite();
int height = buchstabe[nummer].getHoehe();
Image img_out = buchstabe[nummer].getBild();
String buchstabeName = buchstabe[nummer].getBuchstabeName();
Image ausgerichteteImage = createImage(width +10, (int)(ImageGroesse));
Graphics g = ausgerichteteImage.getGraphics();
g.setColor(Color.white);
g.fillRect(0,0, width+10, (int)ImageGroesse);
g.drawImage(img_out,5,o_schnitt,width,height,this);
//Geaenderte Bilder speichern
buchstabe[nummer].setBild(ausgerichteteImage);
return oben;
}
Alle neuen Schriftzeichenbilder haben gleiche Größe und verschiedene Breite. Es
bleiben nur noch die Bilder im Programm darzustellen und die Methoden für manuelle
Korrektur einzubauen.
Das Platzieren von Bildern auf dem Programmfenster erfolgt in der Methode
„darstellen(j)“. Diese Methode bekommt als Übergabeparameter die Nummer von dem
Objekt, dessen Schriftzeichenbild dargestellt werden soll. Jedes Objekt wird in einem
„Panel“ dargestellt.
Die Darstellung von den ausgerichteten Schriftzeichenbildern ist in der Abbildung 34
gezeigt.
123
Abbildung 34 das erste Schriftsatzausrichtungsprogramm
Die manuelle Nachbearbeitung
Die Buchstaben des Alphabets haben so genannte „Serifen“, die außerhalb von oberen
bzw. unteren Grundlinien liegen. Außerdem wurden die Buchstaben eines Typs, beim
Ausrichten, auf eine bestimmte Höhe gebracht, so dass manche Buchstaben ihre
Proportionen nicht beibehalten. die Buchstaben mit der Unterlänge haben zum Beispiel
nicht die gleiche Höhe und beim automatischen Ausrichten werden diese Buchstaben auf
eine Höhe gebracht. Deswegen wird eine Möglichkeit der manueller Korrektur benötigt.
Jedes Schriftzeichenbild, was im Fenster dargestellt wird, befindet sich in einem
„Panel“. Dieses „Panel“ hat die gleiche Größe, wie das Schriftzeichenbild. Beim
Aktivieren des Bildes, per einen Mausklick, bekommt das „Panel“ eine rote Umrandung.
Innerhalb von diesem „Panel“ kann man das Schriftzeichenbild mit dem Mausezeiger
freibewegen. Beim Verschieben des Schriftzeichenbildes wird die Differenz zwischen
der Anfangs- und die Endkoordinate des Mauszeigers gemerkt. So werden die
Anfangskoordinaten des Schriftzeichenbildes auf diese Differenz verschoben und das
Bild innerhalb des „Panels“ an die gewünschte Position gebracht.
Manche Schriftzeichenbilder werden trotz der automatischen Skalierung nicht richtig
dargestellt. Das hängt wiederum von den „Serifen“ und Ausrichtungsalgorithmus ab. In
diesem Fall kann die Größe des Schriftzeichenbildes proportional verändert werden.
Dafür gibt es einen Skalierungsbalken Abbildung 34. Dieses Skalierungsbalken ist auf
100 Teile aufgeteilt. Der Schiebebutton steht Anfangs in der Mitte von dem Balken. Das
124
Schriftzeichenbild kann entweder vergrößert oder auch verkleinert werden. Beim
Verschieben von Skalierungsbalken wird die Klasse „Skalieren()“ aufgerufen und das
Schriftzeichenbild skaliert.
So werden die Schriftzeichenbilder des aktuellen Schriftsatzes in zwei Schritten,
„automatische Ausrichtung“ und „manuelle Nachbearbeitung“, ausgerichtet. Beim
Aktivieren von dem Button „speichern“ werden die alten Bilder in der Datenbank mit
den ausgerichteten Schriftzeichenbildern überschreiben. Der nächste Schriftsatz wird für
die Ausrichtung aus der Datenbank ausgelesen.
Das Ausrichtungsprogramm wird so lange laufen, bis alle Schriftsätze überarbeitet
wurden.
Wenn
alle
Schriftsätze
ausgerichtet
wurden,
beendet
sich
das
Ausrichtungsprogramm.
2.5.1 Auftretende Probleme
Schon beim Anwenden des automatischen Verfahrens wurden Anomalien festgestellt.
So wurden manche Buchstaben mit ganz falschen Größen dargestellt. Die waren größer
oder kleiner als die vordefinierte Höhe. Bei halbkursiven Schriftsätzen Abbildung 35
wurde der Buchstabe „Alef“ falsch dargestellt, da dieser Buchstabe im Programm in die
Standarthöhe platziert war, und bei den halbkursiven Schriftsätzen besitzt der „Alef“
sehr stark ausgeprägten Serifen.
Abbildung 35 Halbkursive Schriftsatz nach der Ausrichtung
Abbildung 36 Quadrate Schriftsatz nach der Ausrichtung
Es hat sehr viel Zeit gefördert die automatisch ausgerichteten Schriftsätze manuell
nachbearbeiten. Bei manchen Schriftsätzen würde es nicht weniger Zeit kosten die
Bilder nachzubearbeiten, als nicht ausgerichteter Schriftsatz ganz von vorne manuell zu
bearbeiten.
125
Nicht nur die Serifen, sondern die falsche Darstellung von den Schriftzeichenbildern
eines Typs haben die Sorgen bereitet. Es sollte eine Lösung für die richtige Darstellung
von den Schriftzeichenbildern gefunden werden.
2.5.2 Problemfindung- Untersuchung von Basisdaten.
Bei der Suche nach einer Lösung für die richtige Darstellung des Schriftzeichenbildes
wurden die Messdaten von den Bildern überprüft.
Beim Prüfen von vorhandenen Messdaten aus der Datenbank wurde festgestellt, dass
mehr als die Hälfte aller Buchstaben falsch vermessen wurden. In der Tabelle 4 ist nur
ein Schriftsatz von mehreren gezeigt, bei dem die Buchstaben falsche Messdaten haben.
Man sieht sofort, dass mehrere Buchstaben keine Breite haben, oder die Dickten des
Buchstabens größer sind als seine Höhe.
Schriftsatz
Name des
Buchstabens
Breite
199902121007/003
Alef
0
199902121007/003
Bet
199902121007/003
Höhe
Obere
untere
Dickte
Dickte
0.6410
4
2.9310
2.31
2.8030
0.8190
0.7790
Gimel
0
0.7820
4
2.8220
199902121007/003
Dalet
2.7070
4
2.1850
0.6870
199902121007/003
Heh
4
0
2.7260
2.2240
199902121007/003
Waw
0.6970
0.6870
4
2.8850
199902121007/003
Sajin
1.0250
2.8330
0.7820
0
199902121007/003
Chet
0
0.6410
4
2.8440
199902121007/003
Tet
2.3530
2.7510
0.7220
0.7050
199902121007/003
Jod
0
0.7130
4
1.8410
126
199902121007/003
Kaf
0.5710
0.7120
4
2.6750
199902121007/003
Endkaf
0.65
0.6090
4
4.4030
199902121007/003
Lamed
4
0.6050
4.1330
1.7420
199902121007/003
Mem
2.8560
4
2.3950
0.5990
199902121007/003
Endmem
4
0
2.7240
2.0850
199902121007/003
Nun
0.5650
0.5410
4
2.8640
199902121007/003
Endnun
0.7050
0.7620
4
4.4310
199902121007/003
Ssamech
4
0.6710
2.7680
2.0720
199902121007/003
Ajin
2.0380
2.8940
0.6410
0
199902121007/003
Peh
4
0
2.6440
1.9660
199902121007/003
Endpeh
0.7050
0.7220
4
4.3620
199902121007/003
Zadeh
4
0
2.7590
2.22
199902121007/003
Endzdeh
4
0.66
4.4930
1.9730
199902121007/003
Kof
0.5910
4.2390
1.8610
199902121007/003
Resch
4
0.5440
2.6560
1.7540
199902121007/003
Shin
4
0.7020
2.6620
2.6620
199902121007/003
Taw
2.8260
4
2.5380
0.7080
Tabelle 4 Falsche Messdaten (ein Schriftsatz)
Aus diesem Ergebnis konnte man Schließen, dass diese Messdaten bei der Ausrichtung
nicht benutzt werden dürfen. So kam man zu einer Entscheidung, die Schriftsätze mit
falschen Messdaten neu zu vermessen.
127
2.6
Ablehnung den alten Algorithmus und Ideen für einen
neuen Ansatz
Aus den Ergebnissen von dem Überprüfen der Messdaten wurde klar, dass mehr als die
hälfte von damals existierenden Schriftsätze neu vermessen werden müssen.
Dabei kam man auf eine neue Idee. Wenn es mehr als die Hälfte aller Schriftsätzen neu
zu Vermessen gab, können gleich alle existierende Schriftsätze neu gemessen werden.
Der Vorteil bestand darin, das Vermessungsprogramm kann in diesem Fall modifiziert
werden. Das Programm kann dann mehr Informationen über die einzelnen Buchstaben
liefern, als nur die Messdaten. Diese Informationen können später in dem
Ausrichtungsprogramm eingesetzt werden.
So kann das Vermessungsprogramm nicht nur Messdaten von einem Bild liefern,
sondern auch die Höhen von den Serifen. Diese Parameter würden einer präziseren
Ausrichtung von Schriftzeichenbildern dienen. Außerdem könnten die Abstände von
dem Bildrand bis zum Buchstaben auch geliefert werden.
Aus diesen Überlegungen stellte sich heraus, dass es noch effiziente wäre nicht die
Abstände von den Bildrändern bis zu Buchstaben liefern, sondern gleich ein GIF-Bild zu
erstellen. Dieses GIF-Bild wird nur den Buchstaben beinhalten, ohne jeglichen Rand.
Das fuhr dazu, dass die GIF-Bilder nicht manuell, sondern während der Vermessung
erstellt werden.
Allerdings bedeutete das, dass die vorhandene Version von dem Ausrichtungsprogramm
für die neuen GIF-Bilder nicht mehr aktuell war.
Man brauchte ein neues Verfahren um die Bilder auszurichten.
128
2.7
Entwicklung des automatischen Ausrichtungsverfahrens
2.7.1 Lösungsweg
Um ein neues Ausrichtungsprogramm zu entwickeln, müssen zuerst die Daten für den
neuen Algorithmus vorbeireitet werden.
Vermessungsprogramm
Die für das Ausrichtungsprogramm notwendige Daten werden mit Hilfe von
Vermessungsprogramm ermittelt. Das Vermessungsprogramm liefert in erster Linie die
Messdaten von dem Buchstaben.
Die GIF-Bilder werden auch im Vermessungsprogramm produziert. Um die GIF-Bilder
zu produzieren, braucht man einen GIF-Erzeuger. Die standarte Java-Klassen bieten
keine Möglichkeiten GIF-Bilder zu erzeugen. Es wurde nach den „Open Source“ JavaKlassen gesucht, die eine Möglichkeit bietet die GIF-Bilder zu erstellen.
Eine Klasse, die aus einem Image einen GIF-Bild erzeugen kann, wird unter folgenden
Adresse
angeboten
http://www.gurge.com/amd/old/java/GIFEncoder/index.html(den
01.12.03). Die ausführliche Information über den GIF-Erzeuger findet man in dem
Kapitel 2.3.4 GIFEncoder.
Bei der Vermessung von dem Buchstaben werden die Höhe und die Breite gemessen.
Dabei werden die Koordinaten von oberen linken und unteren rechten Grenze des
Buchstabens gespeichert. Die Abbildung von dem Buchstaben wird aus dem Image
extrahiert. Dann wird diese Abbildung auf Millimetergröße des Buchstabens mal 25
skaliert. Im Endeffekt wird das Bild ohne Rand und mit entsprechender Proportion zu
der
Messgröße
erstellt.
Dieses
Bild
wird
in
der
Filestruktur
unter
„buchstaben/originalgif“ gespeichert. Um großes Bild von dem Buchstaben nicht
manuell erstellen zu müssen, wird es auch im Vermessungsprogramm erstellt. Nur der
Skalierungsfaktor ist entsprechend größer.
Das Vermessungsprogramm wird so modifiziert, dass zusätzlich die Abstände von dem
oberen Buchstabenrand bis zu oberen Grundlinie geliefert werden. Diese Werte werden
in Millimeter ermittelt und dann auf den Skalierungsfaktor vergrößert, der bei der
Erstellung von den kleinen GIF-Bildern benutzt wurde. Die erstellten Abstände werden
129
in einer Filestruktur unter „buchstaben/grundlinien“ gespeichert. So können auch Serifen
bei der Ausrichtung berücksichtigt werden.
Als Ergebnis vom Vermessungsprogramm bekommt man Buchstaben, die richtig
„aussehen“(einzigartige Breite und Proportionen) aber noch falsch im Schriftsatz
platziert sind. Die Buchstaben eines Schriftsatzes können jetzt ausgerichtet werden.
Ausrichtungsprogramm
In der neuen Version vom Ausrichtungsprogramm wird keine Datenbankverbindung,
wie in der ersten Version gebraucht. Die Bilder werden sofort nach dem Vermessen
ausgerichtet. Dafür werden die Bilder, Messdaten und Grundlinieninformationen aus
einer Filestruktur ausgelesen.
Die Idee für das Platzieren von Schriftzeichenbildern ist gleich geblieben. Die
Schriftzeichenbilder in ein neues Bild zu platzieren, wobei die Höhe des neuen Bildes
für alle Bilder gleich bleibt. Die Schriftzeichenbilder werden nur in diesem neuem Bild
an der richtigen Stelle platziert. Die Höhe des neuen Bildes soll genau so groß sein wie
die Höhe von grössten „normale“ Schriftzeichenbild+ Oberlänge aus dem „Lamed“ +
die größte Unterlänge Abbildung 31.
Als Erweiterung kam die Analyse des Schriftsatzes auf die Vollständigkeit hinzu. Wenn
z.B. „Lamed“ nicht vorhanden ist, soll der Schriftsatz trotzdem ausgerichtet werden.
Wenn später neue Buchstaben dazu kommen, wird es kein Problem sein den ganzen
Schriftsatz neu auszurichten, da die Bilder im Verzeichnis „buchstaben/originalgif“
nicht überschrieben werden.
Die ausgerichteten Schriftsätze werden in eine Filestruktur gespeichert und mit dem
„CDImport“ Programm in die Datenbank Exportiert.
130
2.7.2 Ändern des Vermessungsprogramms
Anleitung
Die frühere Version des Vermessungsprogramms wurde entwickelt, um die originalen
Millimetergrößen des Buchstabens zu ermitteln. Folgende Größen des Buchstabens
wurden berechnet: Höhe, Breite, obere- und die untere Dickten. In der neuen Version
sollen außerdem die Größen von den Serifen ausgerechnet werden. Die GIF-Bildern von
den Buchstaben werden auch automatisch im Vermessungsprogramm erzeugt.
Darstellen von TIFF-Bildern
Die originalen Messgrößen wurden beim vermessen von den TIFF-Bildern ermittelt. Die
TIFF-Bilder werden mit Hilfe von JAI-Bibliothek geladen.
Beim
Laden
des
Bildes
wird
ein
neues
Objekt
„stream“
der
Klasse
„FileSeekableStream()“ erstellt. Dieses Objekt beinhaltet den Datenstrom von dem
entsprechenden TIFF-Bild. Der Pfad zu dem Bild wird mittels Übergabeparameter
„filename“
an
den
Constructor
der
Klasse
übertragen.
Ein
neues
Objekt
„renderedImage“ der Klasse „RenderedOp“ wird erstellt. In dieses Objekt wird der
Datenstrom aus dem „stream“ übertragen. Dafür wird eine Methode „create“ der Klasse
„JAI“ mit zwei Parametern aufgerufen. Der erste Parameter bestimmt den Bildtyp und
der zweite Parameter ist der Datenstrom.
FileSeekableStream stream = null;
try {
stream = new FileSeekableStream(filename);
}
catch (IOException e) {}
RenderedOp renderedImage = JAI.create("tiff", stream);
Das Bild wird auf die Größe des zentralen Fensters skaliert. Für die Skalierung von den
ausgelesenen Images, wurde die Methode von AWT-Bibliothek benutzt. Diese Methode
kann nur auf einen AWT-Image angewendet werden. Deshalb wird das erstellte
RenderedOp-Objekt
zu
einem
AWT-Image
transformiert.
Die
Methode
„getAsBufferedImage()“ umwandelt ein RenderedOp-Objekt zu einem AWT-Image.
awtImage = renderedImage.getAsBufferedImage();
131
Für das Skalieren wird die Methode „getScaledInstance“ an das bestehende AWTImage
angewendet.
An
diese
Methode
werden,
Höhe,
Breite
und
der
Skalierungsalgorithmus übergeben. Von dem Skalierungsalgorithmus hängt die Qualität
und
die
Geschwindigkeit
des
Skalierungsvorgangs
ab.
Der
Parameter
„Image.SCALE_SMOOTH“ gibt die beste Qualität beim skaliertem Bild aus.
awtImage = awtImage.getScaledInstance(Breite, Höhe, Image.SCALE_SMOOTH);
Obwohl der beste Skalierungsalgorithmus angewendet wurde, verloren die skalierten
Bilder ein Teil von den Farbinformationen Abbildung 37.
Abbildung 37 Vermessungsprogramm
Es musste ein anderes Skalierungsalgorithmus an das TIFF-Bild angewendet werden,
um die originelle Farbinformation beizubehalten. Dieses Skalierungsalgorithmus bietet
die JAI-Bibliothek an. Für den Skalierungsvorgang wird die Methode „create“ der
Klasse „JAI“ aufgerufen. Mit dem ersten Parameter „scale“ wird die zu verarbeitende
Aktion festgelegt. Der zweite Parameter ist ein Bild, was skaliert werden muss. Dritte
und vierte Parameter bestimmen den Skalierungsfaktor, auf den das Bild vergrößert bzw.
verkleinert wird. Nächste zwei Parameter bestimmen die Translation des Bildes. Wenn
diese Parameter positive Werte besitzen, verschiebt sich der Inhalt von dem Bild nach
rechts und nach unten. Wenn die Parameter negativ sind wird der Inhalt von Bild nach
links und nach oben verschoben. Defaultmäßig haben die beiden Parameter den Wert
„0.0F“. Der letzte Parameter bestimmt den Skalierungsalgorithmus. In dem
Vermessungsprogramm wurde „InterpolationNearest()“ eingesetzt. Dieses Algorithmus
ist schnellste und liefert beim Skalieren von den Bildern ein akzeptables Ergebnis
Abbildung 38.
132
float scalB = b / (float) renderedImage.getWidth()
float scalH = h / (float) renderedImage.getHeight()
renderedImage = JAI.create("scale", renderedImage, scalB, scalH , 0.0F,
0.0F, new InterpolationNearest());
Grösse von dem Seirf
Abbildung 38 neue Version des Vermessungsprograms
Ermitteln von Serifenhöhen
Beim Vermessen der Höhe des Buchstabens werden die obere und die untere
Koordinaten gemerkt. Entsprechend werden beim Vermessen auch die Koordinaten von
oberen und unteren Dickten entnommen. Aus den vorhandenen Werten läst sich leicht
die Höhe von Serifen ausrechnen Abbildung 38. Beim Ausrechnen wird einfach die
Differenz zwischen der oberen Koordinate des Buchstabens „anfangHoeheKoord“ und
der oberen Koordinate der oberen Dickte „anfangObereGrLine“. Der ermittelte Abstand
wird durch den Skalierungsfaktor „scaleY“ dividiert. Dieser Skalierungsfaktor wurde
beim darstellen von TIFF-Bildern im Fenster angewendet. Die errechnete Differenz
definiert auch den Anfang von der oberen Grundlinie für den bestimmten Buchstaben.
//Abstand von oben bis zu oberen Grundlinie
public double gemessenObereGrundlinie(){
return((anfangObereGrLine – anfangHoeheKoord) / scaleY));
}
133
Die Größe von den unteren Serifen wird im Ausrichtungsprogramm nicht benutzt.
Zuerst haben nicht alle Buchstaben in einem Schriftsatz untere Dickte, und zweitens
werden die Buchstaben eines Schriftsatzes beim Ausrichten auf die obere Grundlinie
geordnet.
Erstellen von GIF-Bildern
Die GIF-Bilder werden mit Hilfe von externer JAVA-Bibliothek erstellt. Davor müssen
jedoch die bestehenden Bildobjekte modifiziert werden. Die TIFF-Bilder beinhalten den
weißen Bereich zwischen dem Bildrand und der Abbildung des Buchstaben. Dieser
Rand wurde in der früheren Version von Ausrichtungsprogramm bei den GIF-Bildern
entfernt. Im Vermessungsprogramm besteht eine bequeme Möglichkeit diesen Rand
noch vor dem Erstellen des GIF-Bildes zu entfernen. Für diese Operation werden wieder
die Koordinaten von dem Vermessen des Buchstabens benutzt. Der Methode
„zuschneiden()“ werden die obere linke X- und Y-Koordinate übergeben. Außerdem
werden die reale Höhe und Breite des Buchstaben in dem TIFF-Bild an diese Methode
gesendet. Ein Imageobjekt „originalTiff“ wird aufgerufen. In diesem Objekt ist
Information von dem nichtskalierten TIFF-Bild gespeichert. Ein neues Rechteck „rect“
wird, mit der Größe und Anfangskoordinaten von der Buchstabenabbildung, erstellt. Die
Farbinformation wird in das Objekt „colmod“ geschrieben. Ein neues AWTImageObjekt wird erzeugt. Dieses Objekt bekommt nur die Farbinformation des TIFF-Bildes,
die zu dem vordefinierten Rechteck gehört. So wird nur die Buchstabenabbildung in das
neue AWTImage-Objekt gespeichert. Das neuerzeugte Bild wird in das RenderedOpObjekt geschrieben, um später eine Skalierungsaktion an diesem Objekt vorzunehmen.
Dafür wird ein Parameterblock „pb“ erstellt. In diesen Block wird das erzeugte
AWTImage platziert. Eine neue Operation „JAI.create("awtImage", pb)“ wird gebildet.
Mittels dieser Operation wird die, im AWTImage vorhandene Information, in das
RenderedOp Objekt übertragen.
public void zuschneiden(int anfangB, int anfangH, int breite, int hoehe) {
RenderedOp im = originalTiff;
if(im != null) {
Rectangle rect = new Rectangle(anfangB, anfangH, breite, hoehe);
ColorModel colmod = im.getColorModel();
Image awtImage = im.getAsBufferedImage(rect,colmod);
//Parameterblock erzeugen
134
pb.add(awtImage);
// Erzeugen neue AWTImage operation
RenderedOp renderedImage = JAI.create("awtImage", pb);
}
}
Die Abbildung von dem Buchstaben muss noch skaliert werden, um eine angemessene
Größe zu bekommen. Diese Größe wird aus den gemessenen Millimeterwerten dieses
Buchstabens ermittelt. Die sämtlichen GIF-Bilder , die früher mit einem Tool erstellt
wurden, waren 60x75px groß. Es sollte ein Skalierungsfaktor gefunden werden, der die
gemessenen Millimetergrößen ungefähr auf die Höhe 75 bringt. Die Breite spielt dabei
keine Rolle, da jeder Buchstabe eine eigene Breite besitzt. Nach den experimentellen
Versuchen wurde festgestellt, dass die Millimeterhöhen der Buchstaben in der Regel 3
bis 4 Millimeter hoch sind. Das heißt, wenn die Millimetergröße des Buchstabens auf
2500% vergrößert wird, kommt man ungefähr auf den Wert 75. Für die großen Bilder
werden die Millimetergrößen auf 25000% skaliert. Die Skalierungsmethode wird
aufgerufen und das Bild auf die vorgerechnete Größe gebracht.
skalierung(renderedImage, realBreite, realHoehe);
Als Ergebnis bekommt man einen skalierten RenderedOp-Objekt. Dieses Objekt kann in
einen GIF umgewandelt werden.
Es wird ein Objekt „gifEncoder“ der Klasse „GIFEncoder“ erstellt. Der Constructor der
Klasse bekommt als Übergabeparameter das RenderedOp-Objekt. Ein Ausgabestrom
„output“ wird erzeugt, und der kodierte Datenstrom wird über die Methode „Write()“
der Klasse „GIFEncoder“in einen GIF-Bild gespeichert.
GIFEncoder gifEncoder = null;
try{
gifEncoder = new GIFEncoder(renderedImage);
}
catch(AWTException ex){}
try{
OutputStream output = new BufferedOutputStream(new
FileOutputStream(dateiName) );
gifEncoder.Write(output);
}
catch(IOException ex){}
135
2.7.3 Entwicklung des Ausrichtungsprogramms
Laden von den Bildern
Die erzeugten GIF-Bilder und die entsprechenden Messdaten liegen in einer Filestruktur.
Diese Filestruktur wird auf eine CD gebrannt und in die Datenbank importiert. Damit
die CD die richtigen Informationen beinhalten, müssen die Schriftzeichenbilder vor dem
Brennvorgang ausgerichtet werden. Deshalb wird in der neuen Version von dem
Ausrichtungsprogramm
keine
Datenbankverbindung
benötigt.
Die
Bilder
und
Informationen werden aus den entsprechenden Verzeichnissen ausgelesen.
Ein Auswahlbox (Abbildung 39) wird in das Ausrichtungsprogramm integriert, mit Hilfe
dessen die Filestruktur ausgewählt werden kann.
Abbildung 39 Auswahlbox
Die
Auswahl
des
entsprechenden
Verzeichnisses
wird
über
die
Methode
„directoryAuswahl()“ des Ausrichtungsprogramms aufgerufen. Es wird ein Objekt „fc“
der Klasse „JFileChooser“ erstellt. Die Methode „setFileSelectionMode()“ bestimmt den
Art
von
auswählbaren
Objekten.
Mit
dem
Parameter
„JFileChooser.DIRECTORIES_ONLY“ bestimmt man, dass nur ein Verzeichnis
ausgewählt werden darf. Ein neues Objekt „file“ der Klasse „File“ wird erzeugt. Dieses
Objekt bekommt den Pfad zu dem ausgewählten Verzeichnis. Wenn der Pfad nicht
ausgewählt wurde, wird die Methode „directoryAuswahl()“ erneut gestartet.
public String directoryAuswahl() {
136
final JFileChooser fc = new JFileChooser();
fc.setFileSelectionMode(JFileChooser.DIRECTORIES_ONLY);
int returnVal = fc.showOpenDialog(null);
File file = null;
if (returnVal == JFileChooser.APPROVE_OPTION){
file = fc.getSelectedFile();
return file.toString();
}
else
return directoryAuswahl();
}
Der Pfad zu der gesamten Filestruktur wird in der Stringvariable „vaterVerzeichniss“
gespeichert. Nach dem Auswahl von dem Verzeichnis werden die Pfade zu den
Unterverzeichnisen automatisch aufgebaut.
bildKlein = vaterVerzeichniss + "\\klein\\";
sicherheitsKopie = vaterVerzeichniss + "\\originalgif\\";
grundlinien = vaterVerzeichniss + "\\grundlinien\\";
Das Vaterverzeichnis soll auf jeden Fall den Pfad zu dem Verzeichnis „buchstabe“
beinhalten, weil sich unter diesem Verzeichnis die Filestruktur für die Bilder befindet.
Die Filestruktur ist folgendermaßen aufgebaut
File-Struktur
Buchtitel
Schlüssel
Illustration
Schmuck
vokalzeichen
ausgedehnte
Importdaten
Schriftsatzname
betonungszeichen
ligaturen
Seiten
satzzeichen
buchstaben
Referenzschlüssel
Rohdaten
gross
alef.gif
klein
alef.gif
vektorisiert
masse
originalgif
alef.gif
grundlinien
alef.dat
Abbildung 40 Filestruktur
137
Nachdem die benötigten Pfaden zu den Verzeichnissen existieren, wird die Methode
„schriftsaetzeLaden()“ aufgerufen. In dieser Methode werden alle Dateinamen aus dem
Verzeichnis „originalgif“ in einen Stringarray „bilderAuflistung“ geladen.
File file = new File(sicherheitsKopie);
String[] bilderAuflistung = file.list();
Ein Array von Objekten „imageLetter“ der Klasse „ImageLetter“ wird erzeugt. In jedes
Objekt werden alle, für die Ausrichtung des einzelnen Buchstaben notwendige
Informationen, gespeichert.
imageLetter = new ImageLetter[bilderAuflistung.length];
In einer for-Schleife werden die „imageLetter“ Objekte mit Informationen gefüllt. Zuerst
wird geprüft, ob der Dateiname zu einem GIF-Bild gehört.
for(int i = 0;i<bilderAuflistung.length;i++) {
if(bilderAuflistung[i].substring((bilderAuflistung[i].length() - 4),
bilderAuflistung[i].length()).equals(".gif")){
Der Name von dem Schriftzeichenbild wird abgefragt und ohne Erweiterung in eine
Stringvariable gespeichert.
//erweiterung entfernen
bildName=bilderAuflistung[i].substring(0,(bilderAuflistung[i].length()-4));
Wie in der ersten Version von Ausrichtungsprogramm, wird es nach den
Buchstabentypen unterschieden. Manche Schriftzeichenbilder existieren in mehreren
Varianten. Diese Varianten müssen auch ausgerichtet werden. Diese Varianten können
eventuell größer sein, als die normalen Schriftzeichenbilder. Der Name von
Schriftzeichenbildvarianten besteht aus dem Schriftzeichenbildnamen und einer
Zahl(zwischen 1 und 9). In der boolean Variable wird überprüft, ob das
Schriftzeichenbild einen bestimmten Buchstabennamen hat.
Es gibt nur einen Buchstaben mit der Oberlänge „Lamed“. Die Größe der Oberlänge
wird aus der Datei „lamed.dat“ ausgelesen. Diese Datei befindet sich im Ordner
„grundlinien“. Das Auslesen von den Werten aus der Datei geschieht in der Methode
„obereGrundlinie()“.
Der
ausgelesene
Wert
wird
in
einer
Stringvariable
„bildGrundlinie“ gespeichert. Das Objekt „imageLetter[i]“ wird initialisiert. Der
Constructor der Klasse „ImageLetter()“ wird mit vier Parametern aufgerufen. Der erste
138
Parameter ist das Image von dem Schriftzeichenbild „(bild(sicherheitsKopie + bildName
+ ".gif")“. Die Methode „bild“ liest das entsprechende Bild aus dem Ordner
„originalgif“ in das AWT-Image. Der zweite Parameter „bildName“ ist der Bildname.
Dritte Parameter „bildKlein + bildName + ".gif"“ gibt den Pfad und den Bildnamen an,
unter dem das ausgerichtete Image als GIF-Bild gespeichert wird. Als vierte Parameter
wird die laufende Nummer „i“ vom Objekt übergeben.
//Oberlaenge
boolean b = Pattern.matches("lamed[0-9]*", bildName);
if (b==true){
grndLine = new File(grundlinien + bildName + ".dat");
//Wert fuer obere Grundlinie aus der Datei auslesen
bildGrundlinie = obereGrundlinie(grndLine);
//Image in ein Array speichern
imageLetter[i] = new ImageLetter(bild(sicherheitsKopie + bildName +
".gif"), bildName, bildKlein + bildName + ".gif", i);
Die Höhe von dem ausgelesenen Image wird aus dem Objekt „imageLetter[i]“ abgefragt
und in die Variable „obrLng“ gespeichert. Wenn es mehrere Abbildungen von dem
Buchstaben „Lamed“ existieren, wird die Höhe der größten Abbildung genommen. Die
Variable „Oberlänge“ bekommt den Wert von dem höchsten „Lamed“. Die eigentliche
Oberlänge wird als ein Doublewert in die Variable „oberlaengeGrundLinie“ gespeichert.
//Hoehe des Images ermitteln
obrLng = imageLetter[i].getOriginalImage().getHeight(this);
if (obrLng > Oberlaenge){
Oberlaenge = obrLng;
//Wert in double umwandeln
oberlaengeGrundLinie = Double.parseDouble(bildGrundlinie);
}
}
Zu den Buchstaben mit einer Sondergröße gehören fünf Buchstaben mit der Unterlänge:
„Kof“, „Endzadeh“, „Endpeh“, „Endnun“ und „Endkaf“.
//Unterlaenge
kof =
Pattern.matches("kof[0-9]*", bildName);
endzadeh =
Pattern.matches("endzadeh[0-9]*", bildName);
endpeh =
Pattern.matches("endpeh[0-9]*", bildName);
endnun =
Pattern.matches("endnun[0-9]*", bildName);
endkaf = Pattern.matches("endkaf[0-9]*", bildName);
ajin = Pattern.matches("ajin[0-9]*", bildName);
139
if (kof == true || endzadeh == true || endpeh == true || endnun == true ||
endkaf == true){
Die Informationen werden genau so ausgelesen, wie beim „Lamed“. Das „imageLetter“
Objekt wird auch auf der gleichen Weise erstellt. Zusätzlich zu dem Erstellen vom
Objekt und Auslesen von Information über die Serifenhöhe, wird von diesen fünf
Schriftzeichenbildern, die höchste Buchstabenabbildung ermittelt. Die Variable
„unterlaengeGrundLinie“ bekommt die Größe der Serifenhöhe von den höchsten
Buchstaben.
untrLng = imageLetter[i].getOriginalImage().getHeight(this);
if (untrLng > Unterlaenge){
Unterlaenge = untrLng;
unterlaengeGrundLinie = Double.parseDouble(bildGrundlinie);
}
Der kleinste Buchstabe „Jod“ besitzt zwar keine Ober- oder Unterlänge, muss trotzdem
getrennt behandelt werden, da es um einen Ausreißer handelt. Die Höhe von dem „Jod“
wird in eine Variable „sonst“ gespeichert.
sonst = imageLetter[i].getOriginalImage().getHeight(this);
Der Buchstabe „Ajin“ wird auch getrennt behandelt, da dieser Buchstabe in mehreren
Fällen eine Unterlänge besitzt. Die Höhe von dem Image dieses Buchstabens wird mit
der Höhe der größten Unterlänge verglichen, und wenn diese Abbildung größer ist, wird
der Wert in die Variable „Unterlänge“ gespeichert.
sonst = imageLetter[i].getOriginalImage().getHeight(this);
if (sonst > Unterlaenge){
Unterlaenge = sonst;
unterlaengeGrundLinie = Double.parseDouble(bildGrundlinie);
}
Nach dem Behandeln von Ausnahmenfällen werden die „imageLetter“ Objekte für die
restlichen Buchstaben erstellt. Diese Buchstaben besitzen eine standarte Höhe. Es wird
die höchste Buchstabenabbildung von diesen Bildern genommen und in die Variable
„Standardwert“ gespeichert. Die Variable „standardGrundLinie“ bekommt die Größe der
Serifenhöhe des höchsten Standartbuchstabens.
140
stdWert = imageLetter[i].getOriginalImage().getHeight(this);
if (stdWert > Standardwert){
Standardwert = stdWert;
standardGrundLinie = Double.parseDouble(bildGrundlinie);
}
Nach dem Auslesen von Informationen und Erstellen von Objekten wird die Höhe für
das Schriftzeichenbild ermittelt. Für jeden Buchstaben wird ein neues Bild erstellt. In
diesem Schriftzeichenbild wird die Buchstabenabbildung an der richtigen Position
platziert. Zuerst überprüft man, ob alle Buchstabentypen existieren. So kann es
vorkommen, dass die Abbildung des Buchstabens „Lamed“ nicht in dem Schriftsatz
existiert. Oder es gibt kein Bild von dem Buchstaben mit einer Unterlänge. Insgesamt
gibt es acht Fallunterschiede. Wenn es zum Beispiel keine Buchstabenabbildungen von
dem Typ „Oberlänge“ und „Unterlänge“ gibt, bekommt das Schriftzeichenbild die Höhe
von dem größten Standartbuchstaben. Die ausgerechnete Schriftzeichenhöhe wird in die
Variable „imageGroesse“ gespeichert.
//000 Oberlänge Unterlänge Standardwert
if (Oberlaenge == 0 && Unterlaenge == 0 && Standardwert == 0)
imageGroesse = sonst;
//001
else if(Oberlaenge==0 && Unterlaenge==0 && Standardwert!=0){
oberlaengeGrundLinie = standardGrundLinie;
imageGroesse = Standardwert ;
}
//010
else if (Oberlaenge==0 && Unterlaenge!=0 && Standardwert==0){
oberlaengeGrundLinie = unterlaengeGrundLinie;
imageGroesse = Unterlaenge;
}
//011
else if (Oberlaenge==0 && Unterlaenge!=0 && Standardwert!=0){
if(Unterlaenge > Standardwert){
if(unterlaengeGrundLinie >= standardGrundLinie){
imageGroesse = Unterlaenge;
}
else{
imageGroesse = standardGrundLinie + Unterlaenge;
}
141
else
if(unterlaengeGrundLinie >= standardGrundLinie){
imageGroesse = unterlaengeGrundLinie + Standardwert;
}
else{
imageGroesse = Standardwert;
}
}
}
//100
else if (Oberlaenge!=0 && Unterlaenge==0 && Standardwert==0)
imageGroesse = Oberlaenge;
//101
else if (Oberlaenge!=0 && Unterlaenge==0 && Standardwert!=0)
imageGroesse = oberlaengeGrundLinie + Standardwert;
//110
else if (Oberlaenge!=0 && Unterlaenge!=0 && Standardwert==0)
imageGroesse = oberlaengeGrundLinie + Unterlaenge;
//111
else if (Oberlaenge!=0 && Unterlaenge!=0 && Standardwert!=0)
imageGroesse = oberlaengeGrundLinie + Unterlaenge;
Die Höhe des Schriftzeichenbildes wurde ermittelt. Es kann damit angefangen werden
die Schriftzeichenbilder zu erstellen und die Buchstabenbilder in diese an die richtige
Position zu platzieren.
Für die Ausrichtung werden alle erstellten Objekte in einer for-Schleife aufgerufen.
//Alle Bilder durchlaufen und an die richtige Position setzen
for(int i = 0;i<imageLetter.length;i++) {
Beim Ausrichten von den Buchstabenbildern wird nur zwischen dem Buchstaben mit
einer „Oberlänge“ und den restlichen Buchstaben unterschieden. Die Bildnamen werden
beim Aufrufen von Objekten „imageLetter“ abgefragt. Es wird eine Methode
„ausrichten()“ mit zwei Parametern aufgerufen. Der erste Parameter bestimmt, wie groß
der
Abstand
von
der
oberen
Grenze
des
Schriftzeichenbildes
bis
zu
Buchstabenabbildung sein soll. Für den „Lamed“ ist dieser Wert gleich null, da dieser
Buchstabe eine Oberlänge besitzt.
Der zweite Parameter „i“ bestimmt die Nummer von dem Objekt, das das auszurichtete
Schriftzeichenbild beinhaltet.
142
b = Pattern.matches("lamed[0-9]*", imageLetter[i].getBildName());
if ( b == true){
ausrichten(0, i);
}
Beim Aufrufen der Methode „ausrichten()“ wird der Abstand von der oberen Grenze des
Schriftzeichenbildes bis zu Buchstabenabbildung, als Parameter übergeben. Differenz
zwischen den Oberlängehöhe des Buchstabens „Lamed“ und der Größe von des Serifs
bei dem aktuellen Buchstaben „oberlaengeGrundLinie - obereSchnitt“.
grndLine = new File(grundlinien + imageLetter[i].getBildName()+ ".dat");
bildGrundlinie = obereGrundlinie(grndLine);
obereSchnitt = Double.parseDouble(bildGrundlinie);
ausrichten((int)(oberlaengeGrundLinie - obereSchnitt), i);
In der Methode „ausrichten()“ werden die Größen des jeweiligen Buchstabenbildes
geladen und in die Variablen „width“ und „height“ gespeichert. Ein neues Image-Objekt
„image“ wird erstellt. Beim Erstellen von diesem Objekt werden die Größen gesetzt. Die
Höhe von dem Objekt wird auf die Größe der Variablen „imageGroesse“ plus zehn
gesetzt. Die Breite wird auf die Breite des Buchstabenbildes „width“ plus zehn gesetzt.
public Image ausrichten(int o_schnitt, int j){
int width = imageLetter[j].getOriginalImage().getWidth(this);
int height = imageLetter[j].getOriginalImage().getHeight(this);
Image neuImage = createImage(width+10, (int)(imageGroesse) + 10);
Der Hintergrund in dem neu erzeugten Image-Objekt wird mit der weißen Farbe gefüllt.
Graphics g = neuImage.getGraphics();
g.fillRect(0,0, width+10, (int)imageGroesse +10);
Das ausgelesene Bild „imageLetter[j].getOriginalImage()“ wird in das neu erzeugte
Image an die richtige Position gebracht. Wobei die Variable „o_schnitt“ beinhaltet den
Abstand zwischen dem Seitenrand des neuen Image und der oberen Grenze der
Buchstabenabbildung.
g.drawImage(imageLetter[j].getOriginalImage(),5,o_schnitt + 5, width,
height, this);
Beim Erstellen von GIF-Bildern im Vermessungsprogramm wurden alle Buchstaben auf
einen bestimmten Koeffizient skaliert. Für die meisten Schriftsätze bekamen die Bilder
akzeptable Größen. In manchen Fällen waren die Millimetergrößen von dem Buchstaben
143
ziemlich groß, und in Folge dessen waren die erstellten GIF-Bilder auch groß Abbildung
41.
Abbildung 41 nicht skalierte GIF-Bilder
Diese Darstellung war nicht akzeptabel, deshalb mussten diese Bilder verkleinert
werden. Das Überprüfen von den Bildgrössen findet auch in der Methode „ausrichten()“
statt. Dafür werden zwei Methoden „skalFaktor()“ und „skalierung()“ aufgerufen. In der
ersten Methode „skalFaktor()“ wird die Proportion ermittelt, auf die das Bild skaliert
werden soll. Die Skalierungsmethoden werden im folgenden Kapitel beschrieben. Das
ausgerichtete Image wird im Objekt „imageLetter“ gespeichert.
//Ueberprueffen, ob bilder nicht zu gross sind.
int skalierungsKoof = 100;
skalierungsKoof = skalFaktor(skalierungsKoof, neuImage.getHeight(this));
neuImage = skalierung(skalierungsKoof, neuImage);
imageLetter[i].setAusgerichteteImage(neuImage);
}
144
Skalierung
Die Methode „skalFaktor()“ bestimmt den Skalierungskoeffizient für die spätere
Skalierung. Das ist eine rekursive Methode, und wird solange aufgerufen, bis die
Bildhöhe kleiner als 200 ist. Die Bildhöhe wird wie folgt berechnet: „bildHoehe =
bHoehe * skalierungsKoof/100“. Beim rekursiven Aufruf verkleinert sich der
Skalierungskoeffizient um eins „skalFaktor(skalierungsKoof-1, bHoehe)“.
public int skalFaktor(int skalierungsKoof, int bHoehe){
int bildHoehe = bHoehe * skalierungsKoof/100;
if(bildHoehe > 200){
skalierungsKoof = skalFaktor(skalierungsKoof-1, bHoehe);
}
return skalierungsKoof/100;
}
Die Methode „skalierung()“ wird nach der „skalFaktor“ aufgerufen. Als
Übergabeparameter bekommt die den ermittelten Skalierungskoeffizient „skalfaktor“
und zuskalierendes Image „imageToScal“. Eine Methode „getScaledInstance“ wird an
das Image angewendet. Das Image wird um das Skalierungskoeffizient skaliert. Der
Parameter „Image.SCALE_SMOOTH“ bestimmt dabei den Skalierungsalgorithmus.
public Image skalierung(int skalfaktor, Image imageToScal){
Image scaled1 = imageToScal.getScaledInstance(imageToScal.getWidth(this) *
skalfaktor, imageToScal.getHeight(this) * skalfaktor, Image.SCALE_SMOOTH);
return scaled1;
}
Nach dem Skalieren, wird das modifizierte Image zurückgegeben „return scaled1“.
Speichern
Die ausgerichteten Schriftzeichenbilder werden in einem Fenster dargestellt Abbildung
42. Einzelnen Schriftzeichenbilder werden in einer Reihe dargestellt, damit man sehen
kann, ob die richtig ausgerichtet wurden. Das Fenster beinhaltet einen Skrollbalken, da
alle Bilder nicht in den sichtbaren Bereich reinpassen. Zusätzlich gibt es einen
Progressbar-Balken. Dieser Balken zeigt, wie viele Schriftzeichenbilder ein Schriftsatz
beinhaltet. Zwei Buttons geben die Möglichkeit, Schriftzeichenbilder zu speichern
„speichern“, oder das Ausrichtungsprogramm zu beenden „cancel“.
145
Abbildung 42 neue Ausrichtungsprogramm
Beim
betätigen
des
Buttons
„speichern“,
müssen
alle
ausgerichteten
Schriftzeichenbildern in GIF-Format umgewandelt und im Verzeichnis „klein“
gespeichert werden. Die Schriftzeichenbilder werden aus dem Objekt „imageLetter“ in
einer for-Schleife ausgelesen und an den GIFEncoder geschickt. Das kodierte Bild wird
in
das
Verzeichnis
„klein“,
unter
dem
entsprechenden
Namen
„imageLetter[i].getGifName()“, als GIF gespeichert.
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
for(int i = 0;i<imageLetter.length;i++) {
if(imageLetter[i].getAusgerichteteImage()!=null){
gifEncoder = null;
// speichert Image als GIF-Datei
try{
gifEncoder = new GIFEncoder(imageLetter[i].getAusgerichteteImage());
}
catch(AWTException ex){}
try{
OutputStream output = new BufferedOutputStream(new
FileOutputStream(imageLetter[i].getGifName()));
gifEncoder.Write(output);
}
catch(IOException ex){}
}
}
System.exit(0);
}
146
2.7.4 Auftretende Probleme
Die Ausrichtung von quadraten Schriftsätzen verlief reibungslos. Beim Ausrichten von
den halbkursiven Schriftsätzen traten manchmal Problemen auf. Dies geschah, weil
beim Vermessen von diesen Schriftsätzen schwierig war, die obere Dickte richtig zu
erfassen Abbildung 43.
Abbildung 43 Lamed
Als Ergebnis waren die Schriftzeichenbilder nach dem Ausrichten nicht richtig
positioniert. Aus diesem Grund wurde entschieden, die Methoden für manuelle
Korrektur in das Ausrichtungsprogramm einzubauen.
2.8
Einbau von Methoden für manuelle Korrigierung
Die manuelle Korrigierung besteht darin, dem Benutzer die Möglichkeit zu geben, nicht
richtig platzierte Bilder auf die richtige Position zu verschieben. Jedes Schriftzeichenbild
ist auf einem Label als „Icon“ dargestellt. Dieses Label ist wiederum in einem Panel
platziert. Auf dem Label wurde ein Mouseevent „MouseDragged“ angewendet, der es
erlaubt diesen Label innerhalb von dem Panel zu verschieben. Zuerst wird ermittelt, um
welches Bild es sich handelt. Die Nummer von dem Bild wird aus dem Labelnamen
ausgelesen „evt.getComponent().getName().substring(5);“. Der Name von dem Label
besteht aus dem „label“ plus die laufende Nummer des Buchstabens „index“.
private void bildLabelMouseDragged(java.awt.event.MouseEvent evt) {
//aus dem array image auslesen
String laufnummer = evt.getComponent().getName().substring(5);
int index = Integer.valueOf(laufnummer).intValue();
Ein neues Image „verschieben“ wird mit den Größen des vorhandenen Bildes erzeugt.
Die Bildgrößen werden aus dem Objekt „imageLetter[index]“ ausgelesen.
147
Image verschieben =
createImage(imageLetter[index].getOriginalImage().getWidth(this),
imageLetter[index].getOriginalImage().getHeight(this));
Das Hintergrund von dem neu erzeugtem Image, wird mit der weißen Farbe gefüllt.
Graphics g = verschieben.getGraphics();
g.fillRect(0,0, imageLetter[index].getOriginalImage().getWidth(this),
imageLetter[index].getOriginalImage().getHeight(this));
Das Bild aus dem Objekt „imageLetter[index]“ wird in das neue Image an die
gewünschte Position platziert. Wobei die Variablen „mouseX“ und „mouseY“ wurden
beim drücken der linken Maustaste, auf das Bild, gespeichert.
g.drawImage(imageLetter[index].getOriginalImage(),evt.getX()mouseX,evt.getY()-mouseY,
imageLetter[index].getOriginalImage().getWidth(this),
imageLetter[index].getOriginalImage().getHeight(this), this);
Und als letztes wird das im Objekt „imageLetter[index]“ vorhandene Bild mit dem
modifizierten überschrieben.
//speichern
imageLetter[index].setAusgerichteteImage(verschieben);
}
2.9
Fertigstellung des Programms
Aus den kompilierten Klassen „SchriftsatzAusrichtung“ , „ImageLetter“ des
Ausrichtungsprogramms und aus der Klasse „GIFEncoder“ wurde eine ausführbare
Datei „SchriftsatzAusrichtung.jar“ erstellt. Es wird die JAI-Bibliothek für den
GIFEncoder benötigt. Diese Bibliothek wird in dem „lib“ Verzeichnis abgelegt.
Damit man das Programm starten kann, wird eine Datei „ausrichtung.bat“ erstellt. Die
sieht wie folgt aus.
java -Xmx512m -jar SchriftsatzAusrichtung.jar
Der Parameter „-Xmx512m“ gibt an, wie viel Arbeitspeicher die Java Virtual Mashine
für dieses Programm in Anspruch nimmt. Virtual Mashine reserviert standartmässig
64Mb. im Arbeitsspeicher, fürs Ausführen einer Java-Anwendung.
148
Resümee
3
Resümee: Ergebnisse und Erkenntnisse der
Diplomarbeit
Das Ziel der Diplomarbeit war die „Erstellung von druckbaren PDF-Dokumenten“ und
„Ausrichtung von hebräischen Schriftzeichenbildern“. Für das Erstellen von druckbaren
PDF-Dokumenten wurden Methoden in das Projekt „Hebräische Typographie im
deutschsprachigen Raum“ integriert. Damit wurde dem Benutzer die Möglichkeit
gegeben, Informationen aus dem Schriftatlas im PDF-Format anzusehen, zu speichern
oder auszudrucken. Durch die Ausrichtung wurden die Verhältnisse der einzelnen
Schriftzeichen in einem Schriftsatz erkennbar gemacht.
In dem ersten Teil der Diplomarbeit, wurden zuerst die auf dem Markt existierende
Produkte analysiert. Es wurde ein Produkt ausgewählt, der den Anforderungen des
Projekts entsprach. Dabei wurde auf folgende Aspekte geachtet:
•
Open Source
•
Unterstützung vom Multilanguage
•
Platformunabhängigkeit
•
Unterstützung von XML und XSL-FO Standards
Der einzige PDF-Erzeuger, der allen Anforderungen entsprach, war FOP. Dieses
Produkt befindet sich noch in der Entwicklungsphase und unterstützt nicht den gesamten
XSL- FO- Standard. In Folge dessen kam es beim Erstellen des PDF-Dokuments zu
falscher Darstellung von „Right to Left“ Sprachen. Das Problem wurde durch die
Implementierung der Methoden für die Unterstützung „Right to Left“ Sprachen gelöst.
An dieser Stelle möchte ich einen besonderen Dank an den Oleg Tkachenko (einer der
Entwickler von FOP) richten, der mir diese Methoden vorzeitig lieferte.
Das einzige ungelöste Problem besteht darin, dass die Silbertrennung für die hebräische
Sprache nicht funktioniert.
Während der Entwicklung und des Testbetriebs, erwies sich das Erzeugen von PDFDokumenten als sehr stabil und zuverlässig, so dass es auch erfolgreich im Projekt
eingesetzt wurde.
149
Resümee
In dem zweiten Teil der Diplomarbeit wurde in die Problematik der Darstellung von
Schriftzeichenbildern angegangen. Bei der früheren Darstellung waren die Verhältnisse
von den einzelnen Schriftzeichenbildern in einem Schriftsatz falsch.
Um dieses Problem zu lösen war es notwendig die Merkmalle einzelnen Buchstaben zu
analysieren. Anhand der in der Analyse gewonnener Erkenntnisse über die
Buchstabenmerkmale, wurde eine Anwendung geschrieben, die Schriftzeichenbilder
ausrichtete. Bei der Entwicklung dieser Anwendung wurden mehrere JavaGrafikbibliotheken eingesetzt.
Bei dem ersten Versuch, einen Schriftsatz auszurichten wurde festgestellt, dass die
benötigten Messdaten teilweise falsch oder unvollständig waren. Es war notwendig, die
Schriftzeichenbilder mit falschen Messdaten neu zu vermessen.
Die Messdaten wurden mit Hilfe von Vermessungsprogramm ermittelt. So kam es zu
einer Entscheidung, das Vermessungsprogramm zu modifizieren. Die modifizierte
Version lieferte zusätzliche Informationen über die Buchstaben. Außerdem wurden die
GIF-Bilder mit diesem Programm erstellt.
Anhand neugewonnenen Informationen wurde versucht, einen vollautomatischen
Algorithmus für die Ausrichtung zu erstellen.
Bei der Ausrichtung von manchen Schriftsätzen, kam es jedoch zu falscher Platzierung
einzelner Schriftzeichenbilder im Schriftsatz. In Folge dessen, wurde eine zusätzliche
Methode für manuelle Korrektur in das Programm eingebaut.
Während des Einsatzes erwies sich das Ausrichtungsprogramm als sehr stabil und
lieferte gute Ergebnisse. Die ausgerichtete Schriftzeichenbilder wurden im gesamten
Projekt eingesetzt.
Mit den Ergebnissen meiner Diplomarbeit wurde dem Benutzer möglich gemacht, die
PDF-Dokumente mit den hebräischen Schriftsätzen zu bekommen und die Proportionen
einzelnen Buchstaben in dem Schriftsatz nachzuvollziehen.
Zum Abschluss möchte ich noch sagen, dass die Arbeit in dem Projekt „Hebräische
Typographie im deutschsprachigen Raum“ mir sehr viel Freude bereitete und ich mit
den Ergebnissen meiner Arbeit sehr zufrieden bin.
150
Glossar
Glossar (Abkürzungen und Begriffserklärungen).
Alphabetisch
Apples
Abkürzung für Macintosh Operation System. Bezeichnung für das mit
MacOS
einer grafischen Benutzeroberfläche ausgestatete Betriebsystem des
Macintosh ab Version 7.5 (vorher: System 7)
AWT
Abstract Windowing Toolkit - ein Paket von Java-Klassen für Graphische
User-Interfaces, die zur Laufzeit vom lokal installierten System sichtbar
gemacht werden. Der Name bedeutet übersetzt abstrakter Werkzeugsatz
für die Arbeit mit Fenstern.
BMP
Bitmap - Bild oder Grafik auf der Basis von Bits. Im allgemeinen sind mit
Bitmaps Rastergrafiken gemeint, bei denen das Bild in unabhängig
voneinander kontrollierbare Einzelpunkte aufgelöst wird. Die Höhe der
Auflösung ergibt sich aus der Anzahl der Einzelpunkte innerhalb einer
festgelegten Fläche.
DIN A4
Eine Standardgröße (210x297 mm) für das Papierformat A4 nach
Deutscher Industrie Norm..
DOM
Document Object Model - plattform- und sprachenneutrales Interface.
Erlaubt Programmen und Skripten, dynamisch auf den Inhalt, die Struktur
und die Stile von Dokumenten zuzugreifen und diese zu verändern. Das
DOM unterstützt ein Standardset von Objekten zur Repräsentation von
HTML und XML Dokumenten und ein Standardmodell, das für die
Kombination dieser Objekte
DTD
Document Type Definition - enthält Vorgaben zur Datenstruktur und zur
Syntax eines XML-Dokuments. Anhand einer DTD erkennt der Client, ob
ein Dokument diesen Vorgaben entspricht und ob es sich einwandfrei
weiterverarbeiten lässt
151
Glossar
FOP
Formatting Object Processor - ist ein Druckformatierer, welcher XMLDokumente gemäss einem XSL-FO Dokument in ein PDF-Dokument
umwandelt. Es können aber auch andere Formate als PDF verwendet
werden, direkte Ausgaben zum Drucker, AWT, PCL und Textdateien sind
möglich. FOP ist ein OpenSource Produkt aus dem Apache Project
G3 / G4
Norm für die Kompression von Rasterbildern, die von der Organisation
CCITT
herausgegeben
wird.
G3
komprimiert
nach
einem
eindimensionalen Algorithmus (zeilenweise); G4 komprimiert nach einem
zweidimensionalen Algorithmus (seitenweise).
GIF
Graphics Interchange Format - ein Dateiformat für den Austausch von
Bildern: Speichert bis 256 Farben, ist gut geeignet für eher einfache
Grafiken, für transparente Bilder oder um kleine Animationen zu erstellen
(Animated GIF).
GIF87a
GIF87a ist die urprünglich im Mai 1987 entworfene Spezifikation, die von
allen Programmen, die GIF-Dateien bearbeiten können verstanden werden
sollte. Speichert bis 256 Farben, ist gut geeignet für die einfachen
Grafiken
HTML
Hypertext Markup Language - standardisierte Seitenbeschreibungssprache
für WWW-Seiten im Internet bzw. Intranet, welche von Dr. Charles F.
Goldfarb entwickelt wurde und in der ISO-Norm 8879 definiert ist. Ein
Markup ist dabei ein Textauszeichnung (fett, kursiv, usw.). Der Begriff
Hyper in HyperText meint dabei das sich der Text aus mehreren verteilten
Texten zusammensetzt die über Links zu erreichen sind.
Interlacing
Auf deutsch heißt der "Zeilensprung"; Bei GIF-Dateien existiert ein 4Phasen-Interlacing: in Phase eins wird jede achte Reihe, in Phase zwei
jede vierte Reihe, dann jede zweite Reihe und zuletzt werden alle
Bildzeilen dargestellt. Die erste Phase beginnt etwa nach der halben
Ladezeit des Bildes. Der Zweck des Interlacing besteht darin, bei
152
Glossar
langsamen Übertragungswegen und / oder großen Bilddateien dem
Benutzer möglichst schnell etwas Sichtbares auf seinen Monitor zu
bringen. Der Nachteil bei der Sache besteht in einer größeren Datei
verglichen mit einem "non-interlaced" GIF.
JDK
Java
Development
Kit.
von
Sun
Microsystems
entwickelte,
herausgegebene und frei verfügbare Entwicklungsumgebung
LGPL
Kleine Allgemeine Öffentliche Lizenz (Lesser General Public License),
gilt für einige besonders bezeichnete Software-Pakete - typischerweise
Programmbibliotheken - von der Free Software Foundation und anderen
Autoren, die beschließen, diese Lizenz zu verwenden.
JPEG
Joint Photographic Experts Group - Dateiformat zur Komprimierung und
Übertragung von Bildern.Ist gut geeignet für detailreiche realitätsnahe
Bilder.
LZW
Eine verlustfreie Komprimierung nach Lempel, Ziv und Welch. Am
effizientesten einzusetzen ist sie bei Bildern mit großen Flächen einer
Farbe. LZW faßt identische Farbflächen beim Speichern zusammen. Die
Speicherplatzersparnis liegt im Bereich von 20% bis 50%.
Microsoft
Windows ist ein Produkt von Microsoft, dass als grafische Erweiterung
Windows
und
Benutzerorfläche
für
MS-DOS
konzipiert
wurde.
Windows
entwickelte sich mittlerweile zu einem eigenständigen Betriebsystem, das
nicht mehr auf DOS augsetz.
MIF
Maplnfo Data Interchange Format - erlaubt die Verbindung von normalen
Daten mit einer Vielzahl von graphischen Elementen. Das MIF-Format
kann als ASCII-Format relativ einfach erstellt und bearbeitet sowie unter
allen von MapInfo unterstützten Betriebssystemen verwendet werden.
MPL
Open-Source-Lizenzbestimmungen von Mozilla. Mit ihr wird geregelt,
153
Glossar
wie mit Software bzw. Quellcode umzugehen ist, die auf Entwicklungen
von Mozilla.org basieren.
PCL
Hewlett Packard Printer Control Language (Druckerbefehlssprache) - von
Hewlett-Packard entwickelte Befehlssprache zum Steuern von "HPkompatiblen" Laser-Druckern.
PDF
Das Portable Document Format (PDF) ist ein (Adobe Acrobat)
Dateiformat, das für den anwendungsunabhängigen Dateiaustausch
definiert wurde. Mit dem Programm Acrobat Reader - das von Adobes
Webserver heruntergeladen werden kann - können Sie jedes PDFDokument lesen und drucken.
PNG
Portable Network Graphics Format - soll der Nachfolger des GIF-Formats
werden. PNG unterstützt 16 Mio. Farben, Transparenz, verlustfreie
Kompression, inkrementelle Anzeige der Grafik
und das Erkennen
beschädigter Dateien.
PS
PostScript - Von Adobe System Inc. 1984 auf den Markt gebrachte
Seitenbeschreibungssprache
für
das
seitenweise
Ausdrucken
und
Speichern von Grafiken und Texten. Das System arbeitet system-, größenund auflösungsunabhängig - die Qualität des Ausdruck richtet sich einzig
nach den technischen Möglichkeiten des Ausgabegerätes.
PSD
Grafik-Format von Adobe Photoshop unter der MS-Windows-Umgebung.
Bitmap-Format mit optionaler
RLE-Kompression, das es erlaubt,
zusätzlich zu den eigentlichen Bilddaten Informationen über
Layer,
Masken und den jeweiligen Farbmodus zu speichern.
SAX
Simple API for XML - Programmierschnittstelle, die den Zugriff auf
XML-Dokumente aus Programmen heraus erlaubt. Bietet sequenzielle
Verarbeitung, Eventhandler für Strukturelemente und Funktionen für die
Fehlerbehandlung
154
Glossar
SGML
Standard Generalized Markup Language - eine Sprache zur Beschreibung
der Struktur von Dokumenten. Diese Beschreibung erfolgt mit Hilfe von
sogenannten 'Tags' mit denen Elemente des Dokuments identifiziert
werden. Bei HTML handelt es sich um eine Anwendung von SGML allerdings ist der ursprüngliche Zweck von SGML in HTML meist
verwaschen, denn die Tags werden in aktuellen HTML Dokumenten eher
zur Formatierung des Dokuments statt zu dessen Strukturierung
verwendet.
Swing
Ein umfangreiches Paket von Java-Klassen für grafische User-Interfaces,
bei denen das Aussehen komplett innerhalb des Java-Programms
festgelegt
wird.
Dies
wird
auch
als
leichtgewichtige
Klassen
bezeichnet(light-weight).
SVG
Scalable Vector Graphics - auf XML basierender W3C-Standard für
Vektorgrafiken. Ist kompatibel zu XHTML, unterstützt DOM und CSS, ist
skriptfähig und erlaubt dynamische und interaktive Grafiken. SVG
konkurriert teilweise mit Flash.
TIFF
Tagged Image File Format - ein besonders häufig verwendetes Bildformat
in der digitalen Bildbearbeitung. TIFF-Bilder können verlustfrei
komprimiert werden, was bei den meisten Fotos nur zu einer geringen
Kompression führt.
TXT
Ein Format für Dateien, die im ASCII-Format gespeichert sind.
UNIX
Ist ein 32Bit Betriebsystem.
UNIX mit
Motif ist eine grafische Benutzeroberfläche für UNIX
Motif
URL
Uniform Resource Locator Eine URL ist mit einem erweiterten
Dateinamen vergleichbar, der den gesamten Weg zu diesem Objekt
(Datei) innerhalb eines Netzes beschreibt. URL beginnt immer mit dem
155
Glossar
verwendeten Übertragungsprotokoll, z.B. "http://“
UTF-8
Unicode-Format, das eine variable Anzahl von Bit pro Zeichen verwendet
W3C
Word Wide Web Consortium - von verschiedenen mit dem INTERNET
eng verbundenen Firmen und Konzernen gegründeter Interessenverband
unter der Leitung des Laboratory for Computer Science am Massachusetts
Institute of Technology in Cambridge, Massachusetts. Das Konsortium
fördert Standards und die Interoperabilität von World Wide WebProdukten.
XEP
XEP Rendering Engine ist ein purer Java Konverter, was die XSL
Dokumenten in das PDF bzw. PostScript Format transformiert.XEP
Rendering Engine konvertiert XML Dokumente in ein druckfähiges
Format (PDF oder PostScript). Die XSL-FO wird für die Darstellung
eingesetzt.
XML
eXtensible Markup Language - eine Sprache zur Beschreibung von
Inhalten und Strukturen. Das extensible meint dabei, das die Sprache um
Elemente
erweiterbar
ist,
sofern
diese
Elemente
anhand
einer
vorgegebenen Art und Weise definiert werden. Der Nachfolger von
HTML wird in XML implementiert werden. XML 1.0 wurde Anfang 1998
vom W3C als Standard verabschiedet.
XSL
eXtensible Style Language - Formatierungsanweisungen zur Darstellung
das Element e von XML-Dateien. Vergleichbar mit CSS unter HTML.
XSL-FO
eXentsible
Stylesheet
Language
Formatting
Objects
-
ist
eine
Paginierungsbeschreibungssprache, welche die Darstellung/Wiedergabe
eines Dokuments im PDF-Format beschreibt.
156
[HTiDR]
Hebräische
Typographie
im
deutschsprachigen
Raum.
Eine
Zwischenbilanz
[EPJOS]
Etymon Systems, Inc. http://www.etymon.com/pjx/ (den 13.11.03)
[ITEXT]
iText von Bruno Lowagie http://www.lowagie.com/iText/ (den 13.11.03)
[XRXEP]
RenderX http://www.renderx.com/ (den 13.11.03)
[FOPAP]
The Apache Software Foundation http://xml.apache.org/fop/index.html
(den 13.11.03)
[XML10]
Extensible Markup Language (XML) 1.0 (Zweite Auflage) http://editionw3c.de/TR/2000/REC-xml-20001006/ (den 13.11.03)
[XSL10]
Расширяемый Язык Таблиц Стилей (XSL) Версия 1.0 (russisch)
http://pyramidin.narod.ru/xsl/index.htm (den 13.11.03)
[USA#9]
Unicode Standard Annex #9. The Bidirectional Algorithm
http://www.unicode.org/reports/tr9/(den 13.11.03)
[LDTWB]
Das Lexikon der deutschen Typografie. Wurde von Wolfgang BeinertRedaktion herausgegeben. http://www.typolexikon.de/ (den 13.11.03)
[EHSKK]
KRAMER, Johannes / KOWALLIK, Sabine „Einführung in die
hebräische Schrift“ 1994. XVI, 3-87118-986-3.
[NGPNS]
Der Name Gimel. Professor Naftali Stern
http://www.gimmels.net/infos.html(den 13.11.03)
[GIHAB]
Глобус Израеля.
(russisch) http://www.israel-globe.org/ulpan/index.php
(den 13.11.03)
[JAIEI]
Java ist auch eine Insel von Christian Ullenboom. Programmieren für die
Java 2-Plattform in der Version 1.4. Galileo Computing 1264 S., 2.,
aktualisierte und erweiterte Auflage 2003, ISBN 3-89842-304-2
http://www.galileocomputing.de/openbook/javainsel2/ (den 13.11.03)
157
[PM2001]
SUN Pressemitteilung Mai 2001 Java Advanced Imaging 1.1 setzt neue
Maßstäbe (den 17.11.03)
[PIJAI]
Programming in Java Advanced Imaging
http://java.sun.com/products/javamedia/jai/forDevelopers/jai1_0_1guide-unc/Encode.doc.html
(den 17.11.03)
[MSIJM]
Multimedia Standarts im Internet. Die Java2 Medien API
http://www-ra.informatik.unituebingen.de/lehre/ss01/pro_internet_ausarbeitung/proseminar_mueller_s
s2001.pdf (den 19.11.03)
[JAITUT]
Java Advanced Imaging Tutorial.
http://developer.java.sun.com/developer/onlineTraining/javaai/
(den 19.11.03)
158
Anhang
Anhang
Von FOP unterstützte Formate
Element
Zustand
root
ja
page-sequence
ja
layout-master-set
ja
page-sequence-master
ja
single-page-master-reference
ja
repeatable-page-masterreference
repeatable-page-masteralternatives
conditional-page-masterreference
Kommentar
ja
ja
ja
simple-page-master
ja
region-body
ja
region-body
ja
region-before
ja
region-after
ja
region-start
ja
159
Anhang
region-end
ja
flow
ja
static-content
ja
block
ja
Z.Z. funktioniert nur als direktes
block-container
teilweise
Kind von fo:flow. Ist für die absolute
Positionierung zu verwenden.
character
ja
external-graphic
ja
instream-foreign-object
ja
inline
ja
leader
teilweise
page-number
ja
page-number-citation
teilweise
table
ja
table-column
ja
table-header
ja
table-footer
ja
table-body
ja
table-row
ja
Arbeitet ohne irgendwelche Probleme
nur für Inhaltsverzeichnis
Spaltenbreite explizit eingeben.
160
Anhang
table-cell
ja
list-block
ja
list-item
ja
list-item-body
ja
list-item-label
ja
basic-link
ja
footnote
ja
footnote-body
ja
wrapper
ja
marker
ja
retrieve-marker
ja
top
ja
right
ja
bottom
ja
left
ja
background-color
ja
background-image
ja
border-before-color
ja
border-before-style
ja
Unterstützt interne und externe
Links
Funktioniert nur mit „solid“
161
Anhang
border-before-width
ja
border-after-color
ja
border-after-style
ja
border-after-width
ja
border-start-color
ja
border-start-style
ja
border-start-width
ja
border-end-color
ja
border-end-style
ja
border-end-width
ja
border-top-color
ja
border-top-style
ja
border-top-width
ja
border-bottom-color
ja
border-bottom-style
ja
border-bottom-width
ja
border-left-color
ja
border-left-style
ja
border-left-width
ja
162
Anhang
border-right-color
ja
border-right-style
ja
border-right-width
ja
Nur ein Wert ist erlaubt. Nur für
padding-before
ja
Blocks implementiert. Die Größe des
Hintergrundbereiches kann bestimmt
werden.
padding-after
ja
padding-start
ja
padding-end
ja
padding-top
ja
padding-bottom
ja
padding-left
ja
padding-right
ja
die gleichen Beschränkungen wie für
padding- before
padding- before
padding- before
padding- before
padding- before
padding- before
padding- before
font-family Listen werden nicht un-
font-family
ja
terstützt, benutzen einzelnen fontfamily Namen.
163
Anhang
font-size
ja
font-style
ja
font-weight
ja
country
ja
language
ja
hyphenate
ja
hyphenation-character
ja
hyphenation-push-charactercount
hyphenation-remaincharacter-count
ja
ja
margin-top
teilweise
Nur für Seiten und Regionen
margin-bottom
teilweise
margin-left
teilweise
margin-right
teilweise
space-before
teilweise
Unterstützt space-before.optimum
space-after
teilweise
Unterstützt space-after.optimum
start-indent
ja
end-indent
ja
display-align
teilweise
Implementiert nur für table-cell und
block-container.
Das
Attribut
164
Anhang
„height“ muss im Vaterknoten tablerow eingestellt werden, sonst hat
dieses Attribut kein Effekt.
height
ja
width
ja
line-height
ja
Nur
text-align
teilweise
die
Werte
„start“,
„end“,
„center“ und „justify“ werden unterstützt.
Nur
text-align-last
teilweise
die
Werte
„start“,
„end“,
„center“ und „justify“ werden unterstützt.
text-indent
ja
white-space-collapse
ja
wrap-option
ja
character
ja
letter-spacing
ja
text-decoration
ja
color
ja
break-after
ja
break-before
ja
keep-together
teilweise
Funktioniert nur mit table-row
165
Anhang
keep-with-next
teilweise
keep-with-previous
teilweise
span
ja
leader-alignment
ja
Außer Wert „page“
leader-pattern
Ja
Außer Wert „use-content“
leader-pattern-width
ja
leader-length
ja
rule-style
ja
rule-thickness
ja
external-destination
ja
internal-destination
ja
blank-or-not-blank
ja
column-count
ja
column-gap
ja
extent
ja
flow-name
ja
initial-page-number
ja
master-name
ja
master-reference
ja
Minimum kann nicht überall benutzt
werden.
166
Anhang
maximum-repeats
ja
media-usage
ja
odd-or-even
ja
page-height
ja
page-position
teilweise
page-width
ja
precedence
ja
Der Wert „last“ ist nicht implementiert.
region-name
border-collapse
teilweise
Implementierung
ist
noch
nicht
komplett.
Der Wert „percentage“ ist noch nicht
column-width
teilweise
implementiert. Stattdessen das Element
"proportional-column-width"
benutzen.
number-columns-spanned
ja
number-rows-spanned
ja
table-omit-footer-at-break
ja
table-omit-header-at-break
ja
id
ja
provisional-label-separation
ja
167
Anhang
provisional-distance-betweenstarts
ja
ref-id
ja
src
ja
border-bottom
ja
border-color
ja
border-left
ja
border-right
ja
border-style
ja
border-top
ja
border-width
ja
margin
teilweise
Nur ein Wert erlaubt
Funktioniert nur mit dem Wert
„solid“
Nur für die Seiten und Regionen.
Nur ein Wert erlaubt. Implementiert
padding
teilweise
nur für Blocks. Die Größe des Hintergrundbereiches
kann
bestimmt
werden.
position
teilweise
Der Wert "inherit" funktioniert nicht.
Tabelle 5 Tabelle 2 Derzeitig von FOP unterstützte Fomate des XSL-FO Standards
168
Anhang
Source Code
/** Diese Funktion erzeugt aus den Teil-XMLBaeumen ein kompletes XMLBaum.
* Dann dann wird mit der Hilfe entspraechender XSL-Datei PDF erzeugt
* und in den outStream reingeschrieben.
* @param response New value of property response.
* @throws ServletException wenn sevlet Fehler erzeugt
* @throws IOException ein- oder ausgabefehler
*/
public void erzeugePDF(HttpServletResponse response)
throws ServletException, java.io.IOException {
this.response = response;
if(log == null) {
log = new ConsoleLogger(ConsoleLogger.LEVEL_WARN);
MessageHandler.setScreenLogger(log);
}
response.setContentType("application/pdf");
try {
// DOM-Baum als XML, mit XMLSerializer, serialisieren.
//Ausgabe Format einstellen
OutputFormat format = new OutputFormat(schriftsatzDetailDoc);
//Ausgabestrom erzeugen
StringWriter stringOut = new StringWriter();
//ein Serialisierer fuer die Ausgabe(dabei wird das DOM-Baum in XML
Strom umgewandelt)
XMLSerializer serial = new XMLSerializer(stringOut, format);
serial.serialize(schriftsatzDetailDoc);
StringReader stringReader = new StringReader(stringOut.toString());
Source xmlSource = new StreamSource(stringReader);
String XSLUrl = XSLPfad + "SchriftsatzDetail_pdf.xsl";
Source xslSource = new StreamSource(new URL(XSLUrl).openStream());
TransformerFactory tFactory = TransformerFactory.newInstance();
Transformer transformer = tFactory.newTransformer(xslSource);
StringWriter resultWriter = new StringWriter();
StreamResult result = new StreamResult(resultWriter);
transformer.transform(xmlSource, result);
//In UTF-8 umwandeln
String text = resultWriter.toString();
byte[] data = text.getBytes("iso-8859-1");
169
Anhang
String isoText = new String(data, "UTF-8");
//Writer und Reader schliessen
stringOut.close();
stringReader.close();
resultWriter.close();
//Beschreiben den Pfad zu config Datei fuer FOP
Driver driver = new Driver();
InputSource userConfigStream = new InputSource(new
URL(userConfig).openStream());
Options options = new Options(userConfigStream);
driver.setRenderer(driver.RENDER_PDF);
driver.setInputSource(new InputSource(new StringReader(isoText)));
driver.setOutputStream(response.getOutputStream());
driver.setLogger(log);
driver.run();
}
catch ( Exception ex ) {
ex.printStackTrace();
}
}
Inhalt der CD
Auf der CD sind folgende Informationen gespeichert:
Das Vermessungsprogram liegt im Verzeichnis „hebrewtypemeassure“
Das Ausrichtungprogram liegt im Verzeichnis „SchriftsatzAusrichtung“
Der Source-Code von dem Vermessungsprogram liegt im Verzeichnis
„Source/hebrewtypemeassure“
Der Source-Code von dem Ausrichtungsprogram liegt im Verzeichnis
„Source /SchriftsatzAusrichtung“
Die XSL-FO Dateien liegen im Verzeichnis „XSL-FO“
Die XML Dateien liegen im Verzeichnis „xml“
Die modifizierte FOP-Version liegt im Verzeichnis „fop-bidi“
Die digitale Version von der Diplomarbeit liegt im Verzeichnis „Ausarbeitung“
170

Erstellung von druckbaren PDF-Dokumenten Ausrichtung von

Transcription

Similar documents

Christa Zenzen

Bilder und Grafiken