Drucken von vielen Dokumentarten

[thE_29]

der flavor gibt an um welches Dokument es sich handlet!

hier ist die Hilfe dafür: DocFlavor.INPUT_STREAM (Java 2 Platform SE v1.4.2)

import javax.print.*;
import javax.print.attribute.*;
import java.io.*;
import javax.print.event.PrintJobListener;
import javax.print.event.PrintJobEvent;
import java.awt.GraphicsEnvironment;


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

 private 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!");
    }
  }

 

[thE_29]

ich habe noch ein weiteres BSP fürs drucken gefunden, wenn man nur einfach einen Text ausdrucken will und kein Dokument!

//Zuerst Aufruf
//....

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 net null sein! 
                    //false steht für den Rahmen und das er mir den Titel ausdruckt hab ich noch nicht geschafft!
                    //standardmäßig ist hochformat!
    //printer.druckeSeite(this,"nix",false,true); //würde es im querformat drucken
}
//ANDERE DATEI//

import java.util.*;
import java.awt.*;
import javax.swing.*; 


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

Hoffe die Kommentare reichen

 

[thE_29]

So und hier habe ich noch die 3te Möglichkeit wie man in Java ausdrucken kann.

Ich habe ein Label gemacht, welches einem dann das Bild was oben liegt ausdruckt (sprich ein Bilderdruck).

Glaube Kommentare sind net notwendig, man kann es einfach reinkopieren (gegebenenfalls die packages setzen) und schon sollte es gehen!

Drucken tut man indem man print() aufruft!

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 aussen
   ***************************************************************************/
  public void print()
  {
    PrinterJob printJob = PrinterJob.getPrinterJob();
    printJob.setPrintable(this);
    if (printJob.printDialog())
    {
      try
      {
        printJob.print();
      }
      catch (Exception PrinterException)
      {
        PrinterException.printStackTrace();
      }
    }
  }
}