Drucken von Dokumenten in Java: Unterschied zwischen den Versionen

Aus Byte-Welt Wiki
Zur Navigation springenZur Suche springen
(Die Seite wurde neu angelegt: „der Flavor gibt an, um welches Dokument es sich handelt. hier ist die Hilfe dafür: {{JAPI|DocFlavor.INPUT_STREAM}} <code=java> import java.awt.GraphicsEnvironm…“)
 
K
 
(4 dazwischenliegende Versionen von einem anderen Benutzer werden nicht angezeigt)
Zeile 1: Zeile 1:
der Flavor gibt an, um welches Dokument es sich handelt.
+
=Drucken von einfachem Text=
 +
Um einfachen Text auszudrucken genügt folgendes Beispiel:
  
hier ist die Hilfe dafür: {{JAPI|DocFlavor.INPUT_STREAM}}
+
==Drucker.java==
 +
<syntaxhighlight lang="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;
  
<code=java>
+
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;
 +
    }
 +
}
 +
</syntaxhighlight>
 +
 
 +
==Test-Methode aus einer aufrufenden Klasse==
 +
 
 +
<syntaxhighlight lang="java">
 +
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
 +
}
 +
</syntaxhighlight>
 +
 
 +
 
 +
=Drucken von Dokumenten=
 +
 
 +
Der Flavor gibt an, um welches Dokument es sich handelt, hier ist die Hilfe dafür: {{JAPI|DocFlavor.INPUT_STREAM}}
 +
 
 +
<syntaxhighlight lang="java">
 
import java.awt.GraphicsEnvironment;
 
import java.awt.GraphicsEnvironment;
 
import java.io.FileInputStream;
 
import java.io.FileInputStream;
Zeile 121: Zeile 367:
 
}
 
}
  
</code=java>
+
</syntaxhighlight>
 +
 
 +
 
 +
=Drucken von Bildern=
 +
Bilder kann man ausdrucken, in dem man bspw. ein JLabel benutzt, das ein Bild beinhaltet.
 +
Folgende, fertige Klasse kann das erledigen:
 +
 
 +
<syntaxhighlight lang="java">
 +
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();
 +
            }
 +
        }
 +
    }
 +
}
 +
</syntaxhighlight>
 +
 
 +
'''Hinweis:''' Gedruckt wird, indem man print() aufruft.
 +
 
 +
[[Kategorie:Java]]
 +
[[Kategorie:Java-Codeschnipsel]]
 +
 
 +
--[[Benutzer:thE_29]] 24.08.2004, 15:50

Aktuelle Version vom 8. März 2018, 19:10 Uhr

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