15.4.1 Grundlagen
Seit der Version 1.1 kann in Java gedruckt werden! Das ist deshalb
bemerkenswert, weil es in den Vorgängerversionen keine Möglichkeit
gab, dies zu tun. Im Laufe der Zeit entwickelten sich zwar einige
inkompatible Erweiterungen, jedoch konnte sich keine von ihnen auf
breiter Front durchsetzen.
Um so erfreulicher ist es, daß das Druck-API der Version 1.1
relativ übersichtlich gehalten wurde und leicht zu verstehen
ist. Es gibt zwar einige Restriktionen und Besonderheiten, die beim
Erstellen von Druckausgaben zu Problemen führen können,
aber für einfache Ausdrucke von Text und Grafik ist die Schnittstelle
recht gut geeignet.
Grundlage der Druckausgabe ist die Methode getPrintJob
der Klasse Toolkit:
public PrintJob getPrintJob(
Frame frame,
String jobtitle,
Properties props
)
|
java.awt.Toolkit |
Sie liefert ein Objekt des Typs PrintJob,
das zur Initialisierung eines Druckjobs verwendet werden kann. Ein
Aufruf von getPrintJob
führt gleichzeitig dazu, daß ein plattformspezifischer
Druckdialog aufgerufen wird, der vom Anwender bestätigt werden
muß. Bricht der Anwender den Druckdialog ab, liefert getPrintJob
den Rückgabewert null,
andernfalls wird der Drucker initialisiert und die Ausgabe kann beginnen.
Die Klasse PrintJob
stellt einige Methoden zur Verfügung, die für den Ausdruck
benötigt werden:
public Graphics getGraphics()
public Dimension getPageDimension()
public int getPageResolution()
public abstract void end()
|
java.awt.PrintJob |
Die wichtigste von ihnen ist getGraphics.
Sie liefert den Devicekontext zur Ausgabe auf den Drucker. Der Rückgabewert
ist ein Objekt vom Typ PrintGraphics,
das aus Graphics
abgeleitet ist und wie ein normaler Devicekontext verwendet werden
kann, der beispielsweise an paint
übergeben wird. Mit Hilfe des von getGraphics
zurückgegebenen Devicekontexts können alle Grafik- und Textroutinen,
die auch in Graphics
zur Verfügung stehen, verwendet werden. Bezüglich der Verwendung
von Farben gilt scheinbar, daß diese bei den linienbezogenen
Ausgaberoutinen nicht unterstützt werden. Hier wird alles schwarz
gezeichnet, was nicht den Farbwert (255, 255, 255) hat. Im
Gegensatz dazu stellen die Füllfunktionen Farben (auf einem Schwarzweiß-Drucker)
als Grauwerte dar. Dabei kann - je nach Druckertyp - auch Weiß
eine Vollfarbe sein und dahinter liegende Objekte verdecken.
15.4.2 Seitenweise Ausgabe
Ein wichtiger Unterschied zu einem bildschirmbezogenen Devicekontext
besteht darin, daß jeder Aufruf von getGraphics
eine neue Druckseite beginnt. Die fertige Druckseite wird durch Aufruf
von dispose
an den Drucker geschickt. Für den Aufbau der Seite, das Ausgeben
von Kopf- oder Fußzeilen, die Seitennumerierung und ähnliche
Dinge ist die Anwendung selbst verantwortlich. Die Methode end
ist aufzurufen, wenn der Druckjob beendet ist und alle Seiten ausgegeben
wurden. Dadurch werden alle belegten Ressourcen freigegeben und die
Druckerschnittstelle geschlossen.
|
Bei der Druckausgabe ist es wichtig zu wissen, wie groß die
Abmessungen des Ausgabegeräts sind. Die hierzu angebotenen Methoden
getPageDimension
und getPageResolution
sind in der aktuellen Version leider vollkommen unbrauchbar. getPageResolution
liefert die tatsächliche Auflösung des Druckers in Pixel
per Zoll (also z.B. 600 für einen Laserjet IV), während
getPageDimension
die Anzahl der Pixel liefert, die sich errechnet, wenn man ein Blatt
Papier im US-Letter-Format (8,5 mal 11 Zoll) mit 72 dpi Auflösung
darstellen würde. Leider erfolgt die Druckausgabe nicht mit 72
dpi, sondern in der aktuellen Bildschirmauflösung, wie sie von
der Methode getScreenResolution
der Klasse Toolkit
geliefert wird. Da diese typischerweise bei 120 dpi liegt, füllen
die von getPageResolution
gelieferten Abmessungen nur etwa 60 % einer Seite. |
 |
|
|
Derzeit gibt es keine portable Lösung für dieses Problem.
Ein Workaround besteht darin, die Papiergröße als fest
anzunehmen (beispielsweise DIN A4 mit 21,0*29,7 cm), davon den nicht
bedruckbaren Rand abzuziehen, das Ergebnis durch 2,54 (Anzahl cm je
Zoll) zu teilen und mit der Auflösung von 120 dpi malzunehmen.
Wir werden weiter unten ein Beispiel sehen, in dem diese Technik angewandt
wird. Portabel ist sie allerdings nicht, denn das Programm muß
Annahmen über die Papier- und Randgröße beisteuern.
Es bleibt demnach zu hoffen, daß die nachfolgenden Versionen
des JDK die Bestimmung der Abmessungen auf eine flexiblere Weise ermöglichen.
|
Durch die fixe Einstellung der Ausgabeauflösung ergibt sich ein
weiteres Problem. So kann ein Drucker mit 600 dpi aus Java heraus
nämlich nur mit der aktuellen Bildschirmauflösung (z.B.
120 dpi) angesteuert werden. Das bedeutet zwar nicht automatisch,
daß Schriften oder schräge Linien mit Treppenmustern dargestellt
werden, denn sie werden meist als Vektorgrafiken an den Drucker übergeben.
Allerdings können beispielsweise keine Pixelgrafiken in der aktuellen
Druckerauflösung ausgegeben werden, denn die Positioniergenauigkeit
eines einzelnen Pixels liegt bei 120 dpi. Eine Lösung für
dieses Problem ist derzeit nicht bekannt. |
|
|
|
15.4.3 Plazierung des Codes zur Druckausgabe
Es gibt grundsätzlich zwei Möglichkeiten, die Druckausgabe
im Programm zu plazieren. Einmal kann die normale paint-Methode
dazu verwendet werden, sowohl Bildschirm- als auch Druckausgaben zu
realisieren. Bei einem Aufruf der Methode print
oder printAll
der Klasse Component
wird nämlich ein PrintJob
erstellt, daraus der Grafikkontext beschafft und an paint
übergeben:
Auf diese Weise kann bereits ohne zusätzliche Erweiterungen eine
einfache Druckausgabe realisiert werden, die der Bildschirmausgabe
relativ ähnlich sieht. Im Gegensatz zu print
gibt printAll
dabei nicht nur die aktuelle Komponente, sondern die komplette Container-Hierarchie
eines komplexen Dialogs aus. Soll innerhalb von paint
unterschieden werden, ob auf den Bildschirm oder den Drucker ausgegeben
wird, so kann mit dem Ausdruck g instanceof
PrintGraphics das übergebene Graphics-Objekt
g auf Zugehörigkeit zur
Klasse PrintGraphics
getestet werden.
Die zweite Möglichkeit, die Druckausgabe zu plazieren, besteht
darin, eine eigene Methode zu schreiben, die nur für die Ausgabe
auf den Drucker verantwortlich ist. Diese könnte zunächst
den PrintJob
und das PrintGraphics-Objekt
beschaffen und anschließend die Abmessungen der Ausgabefläche
wie oben besprochen bestimmen. Die Methode wäre dann nicht darauf
angewiesen, daß sie sowohl für die Bildschirm- als auch
für die Druckausgabe vernünftige Resultate liefern muß,
sondern könnte ihre Ausgaben für die Druckausgabe optimieren.
Der Nachteil bei dieser Löung ist allerdings, daß möglicherweise
Code zum Erstellen der Ausgabe doppelt vorhanden ist und doppelt gepflegt
werden muß.
|
Das nachfolgende Listing kombiniert beide Varianten und demonstriert
dies am Ausdruck einer Testseite. Das Programm erstellt ein Hauptfenster
und ruft zwei Sekunden später die Methode printTestPage
zur Druckausgabe auf. Darin wird zunächst ein PrintJob
erzeugt und dann gemäß dem oben beschriebenen Verfahren
die Ausgabegröße ermittelt. Anschließend wird der
Grafikkontext beschafft und ein Rahmen, einige Textzeilen mit Angaben
zu den Metriken und eine Graustufenmatrix werden ausgegeben. Nach
Ende der Druckausgabe wird die Seite mit dispose
ausgegeben und der Druckjob mit end
geschlossen. Der Code für die Darstellung der Graustufenmatrix
wurde in der Methode paintGrayBoxes
implementiert und wird von der Bildschirm- und Druckausgabe gemeinsam
verwendet:
001 /* Listing1508.java */
002
003 import java.awt.*;
004 import java.awt.event.*;
005
006 public class Listing1508
007 extends Frame
008 {
009 public static void main(String[] args)
010 {
011 Listing1508 wnd = new Listing1508();
012 }
013
014 public Listing1508()
015 {
016 super("Listing1508");
017 addWindowListener(
018 new WindowAdapter() {
019 public void windowClosing(WindowEvent event)
020 {
021 System.exit(0);
022 }
023 }
024 );
025 setBackground(Color.lightGray);
026 setSize(400,400);
027 setVisible(true);
028 //Ausdruck in 2 Sekunden starten
029 try {
030 Thread.sleep(2000);
031 } catch (InterruptedException e) {
032 //nichts
033 }
034 printTestPage();
035 }
036
037 public void paint(Graphics g)
038 {
039 paintGrayBoxes(g, 40, 50);
040 }
041
042 public void printTestPage()
043 {
044 PrintJob pjob = getToolkit().getPrintJob(
045 this,
046 "Testseite",
047 null
048 );
049 if (pjob != null) {
050 //Metriken
051 int pres = pjob.getPageResolution();
052 int sres = getToolkit().getScreenResolution();
053 Dimension d2 = new Dimension(
054 (int)(((21.0 - 2.0) / 2.54) * sres),
055 (int)(((29.7 - 2.0) / 2.54) * sres)
056 );
057 //Ausdruck beginnt
058 Graphics pg = pjob.getGraphics();
059 if (pg != null) {
060 //Rahmen
061 pg.drawRect(0, 0, d2.width, d2.height);
062 //Text
063 pg.setFont(new Font("TimesRoman",Font.PLAIN,24));
064 pg.drawString("Testseite",40,70);
065 pg.drawString(
066 "Druckerauflösung : " + pres + " dpi",
067 40,
068 100
069 );
070 pg.drawString(
071 "Bildschirmauflösung : " + sres + " dpi",
072 40,
073 130
074 );
075 pg.drawString(
076 "Seitengröße : " + d2.width + " * " + d2.height,
077 40,
078 160
079 );
080 //Graustufenkästchen
081 paintGrayBoxes(pg, 40, 200);
082 //Seite ausgeben
083 pg.dispose();
084 }
085 pjob.end();
086 }
087 }
088
089 private void paintGrayBoxes(Graphics g, int x, int y)
090 {
091 for (int i = 0; i < 16; ++i) {
092 for (int j = 0; j < 16; ++j) {
093 int level = 16 * i + j;
094 g.setColor(Color.black);
095 g.drawRect(x + 20 * j, y + 20 * i, 20, 20);
096 g.setColor(new Color(level, level, level));
097 g.fillRect(x + 1 + 20 * j, y + 1 + 20 * i, 19, 19);
098 }
099 }
100 }
101 }
|
Listing1508.java |
Listing 15.8: Ausdruck einer Testseite
|
|
|
|
Die Bildschirmausgabe des Programms kann Abbildung 15.8
entnommen werden. Die Druckausgabe sieht ähnlich aus, enthält
aber zusätzlich noch einen Rahmen und die Textausgabe mit den
Informationen zu den Druckmetriken.
Abbildung 15.8: Das Programm zur Druckausgabe
|
Im JDK 1.2 wurde das Konzept der Druckausgabe erneut geändert.
Anstelle der oben beschriebenen Klassen werden nun die Klassen und
Interfaces aus dem Paket java.awt.print
verwendet (beispielsweise PrinterJob,
Printable
und Pageable).
Leider war das neue Drucksystem mit der Ausgabe der Version 1.2 noch
nicht stabil genug, um hier ausführlich beschrieben zu werden.
Im Usenet wurden eine Vielzahl von Problemen und Schwierigkeiten mit
unterschiedlichen Druckertypen und Betriebssystemen diskutiert. Wir
werden die Neuerungen daher hier noch nicht behandeln, sondern sie
zu gegebener Zeit in der Online-Version des Buchs aufgreifen. |
|
|
|