Drucken von Dokumenten in Java

Aus Byte-Welt Wiki
Wechseln zu: Navigation, Suche

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