Drucken von Dokumenten in Java

Drucken von einfachem Text

Um einfachen Text auszudrucken genügt folgendes Beispiel:

Drucker.java

<code=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;
   }

} </code=java>

Test-Methode aus einer aufrufenden Klasse

<code=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

} </code=java>

Drucken von Dokumenten

Der Flavor gibt an, um welches Dokument es sich handelt, hier ist die Hilfe dafür: DocFlavor.INPUT_STREAM

<code=java> 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!");
       }
   }

}

</code=java>

Drucken von Bildern

Bilder kann man ausdrucken, in dem man bspw. ein JLabel benutzt, das ein Bild beinhaltet. Folgende, fertige Klasse kann das erledigen:

<code=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();
           }
       }
   }

} </code=java>

Hinweis: Gedruckt wird, indem man print() aufruft.

--Benutzer:thE_29 24.08.2004, 15:50