Drucken von Dokumenten in Java
Aus Byte-Welt Wiki
Zur Navigation springenZur Suche springenInhaltsverzeichnis
Drucken von einfachem Text
Um einfachen Text auszudrucken genügt folgendes Beispiel:
Drucker.java
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.JobAttributes;
import java.awt.PageAttributes;
import java.awt.PrintJob;
import java.util.ArrayList;
import javax.swing.JFrame;
public class Drucker {
private String[] data;
private ArrayList ar = null;
private Font myFont = new Font("SansSerif", Font.PLAIN, 12);
/**
* *************************************************************************
*
* Fügt einen String hinzu und geht danach in die nächste Zeile
*
* @param Text String
*
* *************************************************************************
*/
public void addString(String Text) {
if (ar == null) {
ar = new ArrayList();
ar.add(Text);
} else {
ar.add(Text);
}
}
/**
* ************************************************************************
*
* fügt eine leerzeile hinzu
*
* ************************************************************************
*/
public void addLeerzeile() {
if (ar != null) {
ar.add("\n");
}
}
/**
* ************************************************************************
*
* Fügt einen Tab hinzu und somit kann man in der gleichen Zeile
* weiterschreiben
*
************************************************************************
*/
public void addTab() {
if (ar != null) {
ar.add("\t");
}
}
void druckeSeite(JFrame f, String title, boolean bRand) {
druckeSeite(f, title, bRand, false);
}
/**
* **************************************************************************
*
* Druckt schließlich die Seite und ob ein Rand dabei ist oder nicht
*
* @param f JFrame
*
* @param title Titel
*
* @param bRand Rand
*
* @param bLandscape ob es querformat(true) oder hochformat ist (false)
*
**************************************************************************
*/
void druckeSeite(JFrame f, String title, boolean bRand, boolean bLandscape) {
//falls der Frame null ist
if (f == null) {
f = new JFrame();
}
PageAttributes page = new PageAttributes();
if (bLandscape) {
page.setOrientationRequested(PageAttributes.OrientationRequestedType.LANDSCAPE);
} else {
page.setOrientationRequested(PageAttributes.OrientationRequestedType.PORTRAIT);
}
PrintJob prjob = f.getToolkit().getPrintJob(f, title, new JobAttributes(), page);
if (null != prjob) {
final int iScreenResol = f.getToolkit().getScreenResolution();
final int iPageResol = prjob.getPageResolution();
final Dimension dimScreenSize = f.getToolkit().getScreenSize();
final Dimension dimPageDimension = prjob.getPageDimension();
Graphics pg = prjob.getGraphics();
if (null != pg && 0 < iPageResol) {
//merkt sich die Größe
int iAddY = pg.getFontMetrics(this.myFont).getHeight();
int iRand = (int) Math.round(iPageResol * 2. / 2.54); // 2 cm Rand
int iPosX = iRand + iRand / 4; // Textposition
int iPosY = iPosX - iAddY / 2;
int iWdth = dimPageDimension.width - iRand * 2; // innere Breite
int iMidY = dimPageDimension.height / 2;
//setzt die Schrift und die Schriftgröße
pg.setFont(myFont);
if (ar != null) {
data = (String[]) ar.toArray(new String[ar.size()]);
for (int x = 0; x != data.length; x++) {
//fügt ein Leerzeichen hinzu
if (data[x].equals("\n")) {
iPosY += (iAddY * 0.65); //nicht die komplette Höhe nehmen
} else if (data[x].equals("\t")) {
//der 10 steht für die Breite des Tabs, variable vereinbar
iPosX += (iAddY * 2 / 3) * 10;
//wenn die Tab position schon weiter ist, als die Weite, dann wird auf
//Anfang gesetzt und neue Zeile
if (iPosX > iWdth) {
iPosX = iRand + iRand / 4;
iPosY += iAddY;
} else {
iPosY -= iAddY;
}
} //wenn nichts erfüllt wird, wird einfach dazugehängt
else {
String str[] = seperateString(data[x], pg.getFontMetrics(myFont), true, iWdth);
for (int y = 0; str != null && y != str.length; y++) {
if (y > 0) {
iPosY += (iAddY * 0.65); //nicht die komplette Höhe nehmen
}
pg.drawString(str[y], iPosX, iPosY += iAddY);
}
}
}
//Buffer wird geleert
ar = null;
} //wenn man noch gar nix hineingeschrieben hat, wird der Fehlertext gedruckt,
//variable abendbar, ob überhaupt gedruckt werden soll
else {
pg.drawString("Error, not initialized", iPosX, iPosY += iAddY);
}
//wenn rand true ist, wird ein Rand gezeichnet
if (bRand) {
pg.drawRect(iRand, iRand, iWdth, dimPageDimension.height - iRand * 2);
}
pg.dispose();
}
prjob.end();
}
}
/**
* **************************************************************************
*
* Funktion zerlegt die Strings für die Anpassung am Bildschirm
*
* @param strText String der Text
*
* @param fontMet FontMetrics welche Schriftart
*
* @param wrapword boolean ob Wörter abgeteilt werden sollen oder nicht
*
* @param iWidth int die Breite des Blatts
*
* @return String[]
*
**************************************************************************
*/
private String[] seperateString(String strText, FontMetrics fontMet, boolean wrapword, int iWidth) {
ArrayList myTmp = new ArrayList();
int z = 0; //merkt sich den Index
//geht die Wörter durch und sollte sie abteilen
for (int x = 0, y = 0; x != strText.length(); x++) {
y += fontMet.charWidth(strText.charAt(x));
if (y > iWidth) {
y = 0;
x--;
//wenn wrapword ist, bei einem Leerzeichen abtrennen
if (wrapword) {
x = strText.lastIndexOf(" ", x) + 1; //+1 damit er das Leerzeichen mitausdruckt und nicht in der nächsten Zeile steht
}
myTmp.add(strText.substring(z, x));
z = x;
}
}
//damit er auch den letzten Teil hinzufügt
myTmp.add(strText.substring(z, strText.length()));
//Gibt die ArrayListe als String Objekt zurück
return (String[]) myTmp.toArray(new String[myTmp.size()]);
}
/**
* **************************************************************************
*
* Funktion setzt eine neue Schriftart
*
* @param font Font *
* *************************************************************************
*/
public void setFont(Font font) {
this.myFont = font;
}
}
Test-Methode aus einer aufrufenden Klasse
public void test()
{
Drucker printer = new Drucker();
printer.addString("Daten");
printer.addLeerzeile();
printer.addTab();
printer.addString("JUHU");
printer.druckeSeite(this, "nix", false); //this ist ein frame/panel/container, es darf halt nicht ''null'' sein!
//false steht für den Rahmen. Dass der Titel ausdruckt wird, habe ich noch nicht geschafft!
//standardmäßig ist Hochformat
//printer.druckeSeite(this,"nix",false,true); //würde es im Querformat drucken
}
Drucken von Dokumenten
Der Flavor gibt an, um welches Dokument es sich handelt, hier ist die Hilfe dafür: DocFlavor.INPUT_STREAM
import java.awt.GraphicsEnvironment;
import java.io.FileInputStream;
import javax.print.Doc;
import javax.print.DocFlavor;
import javax.print.DocPrintJob;
import javax.print.PrintService;
import javax.print.PrintServiceLookup;
import javax.print.ServiceUI;
import javax.print.SimpleDoc;
import javax.print.attribute.DocAttributeSet;
import javax.print.attribute.HashDocAttributeSet;
import javax.print.attribute.HashPrintRequestAttributeSet;
import javax.print.attribute.PrintRequestAttributeSet;
import javax.print.event.PrintJobListener;
import javax.print.event.PrintJobEvent;
public class PrintDocument {
private MyDruckListener drucker = new MyDruckListener();
public PrintDocument(String strFilename, int iDevice) {
try {
PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet();
//setzt das auszudruckend Dokument fest
DocFlavor flavor = DocFlavor.INPUT_STREAM.XXX; //hier nachsehen, welches man benötigt!
PrintService printService[] = PrintServiceLookup.lookupPrintServices(
flavor, pras);
PrintService defaultService = PrintServiceLookup.
lookupDefaultPrintService();
PrintService service = null;
//wenn als Device -1 übergeben wird, wird ein Dialog für das drucken auswählen ausgegeben!
if (iDevice == -1) {
service = ServiceUI.printDialog(GraphicsEnvironment.
getLocalGraphicsEnvironment().
getDefaultScreenDevice().
getDefaultConfiguration(), 200, 200,
printService, defaultService, flavor, pras);
}
//ansonsten wird der 1te (Standard/Default) Drucker genommen
else {
//wenn es keine Drucker gibt und das Device niedriger ist als die Länge
if (printService != null && printService.length != 0 && printService.length > iDevice) {
service = printService[iDevice];
}
//ansonsten standarddevice
else if (printService != null && printService.length != 0) {
service = printService[0];
}
}
//wenn der Dateiename null ist, wird die Druckfunktion beendet!
if (strFilename == null) {
return;
}
//wenn der Service nicht null ist, wird ausgedruckt
if (service != null) {
DocPrintJob job = service.createPrintJob();
//fügt listener hinzu
job.addPrintJobListener(drucker);
FileInputStream fis = new FileInputStream(strFilename);
DocAttributeSet das = new HashDocAttributeSet();
Doc doc = new SimpleDoc(fis, flavor, das);
job.print(doc, pras);
}
} //wenn kein Druckerdevice gefunden wurde!!
catch (ArrayIndexOutOfBoundsException ex) {
ex.printStackTrace();
System.out.println("Keine Drucker gefunden!!");
}
//bei sonstigen Exceptions!
catch (Exception ex) {
ex.printStackTrace();
}
}
class MyDruckListener implements PrintJobListener {
public void printDataTransferCompleted(PrintJobEvent printJobEvent) {
System.out.println("Daten wurden zum Drucker geschickt!");
}
public void printJobCompleted(PrintJobEvent printJobEvent) {
System.out.println("Drucker hat fertig gedruckt!");
}
public void printJobFailed(PrintJobEvent printJobEvent) {
System.out.println("Fehler beim Drucken!");
}
public void printJobCanceled(PrintJobEvent printJobEvent) {
System.out.println("Abbruch des druckes!");
}
public void printJobNoMoreEvents(PrintJobEvent printJobEvent) {
System.out.println("JobNoMoreEvents!");
}
public void printJobRequiresAttention(PrintJobEvent printJobEvent) {
System.out.println("JobRequieresAttention!");
}
}
}
Drucken von Bildern
Bilder kann man ausdrucken, in dem man bspw. ein JLabel benutzt, das ein Bild beinhaltet. Folgende, fertige Klasse kann das erledigen:
import java.awt.print.Printable;
import java.awt.Graphics;
import java.awt.print.PageFormat;
import java.awt.print.PrinterException;
import javax.swing.JLabel;
import javax.swing.Icon;
import java.awt.Graphics2D;
import java.awt.print.PrinterJob;
public class PrintableLabel extends JLabel implements Printable {
/**
* **************************************************************************
*
* Konstruktor für das
*
* @param Image Icon
*
***************************************************************************
*/
public PrintableLabel(Icon Image) {
super(Image);
}
/**
* **************************************************************************
*
* Überschriebene Methode fürs eigentliche Ausdrucken
*
* @param graphics Graphics
*
* @param pageFormat PageFormat
*
* @param pageIndex int
*
* @return int
*
* @throws PrinterException
*
**************************************************************************
*/
public int print(Graphics graphics, PageFormat pageFormat, int pageIndex) throws
PrinterException {
if (pageIndex >= 1) {
return Printable.NO_SUCH_PAGE;
}
Graphics2D g = (Graphics2D) graphics;
g.translate(pageFormat.getImageableX(), pageFormat.getImageableY());
paint(g);
return Printable.PAGE_EXISTS;
}
/**
* **************************************************************************
*
* Druckmethode von außen
*
**************************************************************************
*/
public void print() {
PrinterJob printJob = PrinterJob.getPrinterJob();
printJob.setPrintable(this);
if (printJob.printDialog()) {
try {
printJob.print();
} catch (PrinterException e) {
e.printStackTrace();
}
}
}
}
Hinweis: Gedruckt wird, indem man print() aufruft.
--Benutzer:thE_29 24.08.2004, 15:50
