Java/2D Graphics GUI/Print
Содержание
- 1 Another print demo
- 2 Book
- 3 Book demo
- 4 Create PageFormats on a higher level
- 5 Displaying the Page Format Dialog: changes the default page format such as orientation and paper size.
- 6 Display the print dialog and print
- 7 Listening for Print Service Status Changes
- 8 Overriding the Default Action of a JTextComponent
- 9 Pageable Text
- 10 Printable Component
- 11 Printable demo
- 12 Printable Document
- 13 Print an Image to print directly
- 14 Print Dialog: change the default printer settings(default printer, number of copies, range of pages)
- 15 PrintFile -- Print a file named on the command line
- 16 Print Image
- 17 Printing Pages with Different Formats
- 18 Printing the Combined-Java 1.2-and-1.4 Way
- 19 Printing the Java 1.1 Way
- 20 Printing the Java 1.4 Way
- 21 Printing to a File
- 22 Print in Java 2: PrinterJob
- 23 Print in Java 5
- 24 Print in Java 6
- 25 Print in Java: Multi page
- 26 Print in Java: page format and document
- 27 PrintPanel is the base for an open-ended series of classes
- 28 Print Swing components
- 29 Print the printable area outline
- 30 Print the text file and print preview them
- 31 Print to the standard output
- 32 Prompting for a Printer
- 33 Scribble
- 34 Setting the Orientation of a Printed Page
- 35 Shapes Print
- 36 Simple Book for printing
- 37 Simplest SWT Print Example
- 38 The area of the actual page
- 39 The area of the printable area
- 40 The Printing code which implements Printable
Another print demo
<source lang="java"> import java.awt.BorderLayout; import java.awt.Color; import java.awt.Container; import java.awt.Font; import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JPanel; public class AnotherPrintDemo extends JFrame {
DrawingCanvas canvas; JButton setUpButton = new JButton("Page Setup"); JButton printButton = new JButton("Print"); JButton cancelButton = new JButton("Cancel"); public AnotherPrintDemo() { super(); Container container = getContentPane(); canvas = new DrawingCanvas(); container.add(canvas); JPanel panel = new JPanel(new GridLayout(1, 3)); ButtonListener buttonListener = new ButtonListener(); setUpButton.addActionListener(buttonListener); panel.add(setUpButton); printButton.addActionListener(buttonListener); panel.add(printButton); cancelButton.addActionListener(buttonListener); panel.add(cancelButton); container.add(BorderLayout.SOUTH, panel); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); setSize(650, 275); setVisible(true); } class ButtonListener implements ActionListener { PrinterJob printJob; PageFormat pageFormat; PrintableCanvas printableCanvas; ButtonListener() { printJob = PrinterJob.getPrinterJob(); pageFormat = printJob.defaultPage(); } public void actionPerformed(ActionEvent e) { JButton tempButton = (JButton) e.getSource(); if (tempButton.equals(setUpButton)) { pageFormat = printJob.pageDialog(pageFormat); printJob.validatePage(pageFormat); } else if (tempButton.equals(printButton)) { printableCanvas = new PrintableCanvas(pageFormat); printJob.setPrintable(printableCanvas); boolean ok = printJob.printDialog(); if (ok) { try { printJob.print(); } catch (Exception pe) { System.out.println("Printing Exception Occured!"); pe.printStackTrace(); } } } else if (tempButton.equals(cancelButton)) { printJob.cancel(); } } } public static void main(String arg[]) { new AnotherPrintDemo(); }
} class DrawingCanvas extends JPanel {
Font font; FontMetrics fontMetrics; int w, h; DrawingCanvas() { setBackground(Color.white); setSize(400, 275); w = this.getWidth(); h = this.getHeight(); font = new Font("Dialog", Font.BOLD, 50); fontMetrics = getFontMetrics(font); } public void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2D = (Graphics2D) g; paintContent(g2D, w, h); } public void paintContent(Graphics2D g2D, int w, int h) { g2D.setFont(font); g2D.drawString("Java Source and Support", 0, (float) (0.5 * h - 1.25 * fontMetrics.getHeight())); }
} class PrintableCanvas implements Printable {
DrawingCanvas canvas; PageFormat pageFormat; public PrintableCanvas(PageFormat pf) { pageFormat = pf; } public int print(Graphics g, PageFormat pageFormat, int pageIndex) throws PrinterException { if (pageIndex >= 1) { return Printable.NO_SUCH_PAGE; } Graphics2D g2D = (Graphics2D) g; canvas = new DrawingCanvas(); canvas.paintContent(g2D, (int) pageFormat.getImageableWidth(), (int) pageFormat.getImageableHeight()); // successful printing of the page return Printable.PAGE_EXISTS; }
}
</source>
Book
<source lang="java"> import java.awt.Color; import java.awt.ruponent; import java.awt.Font; import java.awt.GradientPaint; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Paint; import java.awt.font.FontRenderContext; import java.awt.font.LineMetrics; import java.awt.geom.Rectangle2D; import java.awt.print.Book; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; import javax.swing.JComponent; public class Booker {
public static void main(String[] args) { PrinterJob pj = PrinterJob.getPrinterJob(); // Create two Printables. Component c1 = new PatchworkComponent("Printable 1"); Component c2 = new PatchworkComponent("Printable 2"); c1.setSize(500, 400); c2.setSize(500, 400); BookComponentPrintable printable1 = new BookComponentPrintable(c1); BookComponentPrintable printable2 = new BookComponentPrintable(c2); // Create two PageFormats. PageFormat pageFormat1 = pj.defaultPage(); PageFormat pageFormat2 = (PageFormat) pageFormat1.clone(); pageFormat2.setOrientation(PageFormat.LANDSCAPE); // Create a Book. Book book = new Book(); book.append(printable1, pageFormat1); book.append(printable2, pageFormat2); // Print the Book. pj.setPageable(book); if (pj.printDialog()) { try { pj.print(); } catch (PrinterException e) { System.out.println(e); } } }
} class PatchworkComponent extends JComponent implements Printable {
private float mSide = 36; private float mOffset = 36; private int mColumns = 8; private int mRows = 4; private String mString = "Java Source and Support"; private Font mFont = new Font("Serif", Font.PLAIN, 64); private Paint mHorizontalGradient, mVerticalGradient; public PatchworkComponent() { float x = mOffset; float y = mOffset; float halfSide = mSide / 2; float x0 = x + halfSide; float y0 = y; float x1 = x + halfSide; float y1 = y + (mRows * mSide); mVerticalGradient = new GradientPaint(x0, y0, Color.darkGray, x1, y1, Color.lightGray, true); x0 = x; y0 = y + halfSide; x1 = x + (mColumns * mSide); y1 = y + halfSide; mHorizontalGradient = new GradientPaint(x0, y0, Color.darkGray, x1, y1, Color.lightGray, true); } public PatchworkComponent(String s) { this(); mString = s; } public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; g2.rotate(Math.PI / 24, mOffset, mOffset); for (int row = 0; row < mRows; row++) { for (int column = 0; column < mColumns; column++) { float x = column * mSide + mOffset; float y = row * mSide + mOffset; if (((column + row) % 2) == 0) g2.setPaint(mVerticalGradient); else g2.setPaint(mHorizontalGradient); Rectangle2D r = new Rectangle2D.Float(x, y, mSide, mSide); g2.fill(r); } } FontRenderContext frc = g2.getFontRenderContext(); float width = (float) mFont.getStringBounds(mString, frc).getWidth(); LineMetrics lm = mFont.getLineMetrics(mString, frc); float x = ((mColumns * mSide) - width) / 2 + mOffset; float y = ((mRows * mSide) + lm.getAscent()) / 2 + mOffset; g2.setFont(mFont); g2.setPaint(Color.white); g2.drawString(mString, x, y); } public int print(Graphics g, PageFormat pageFormat, int pageIndex) { if (pageIndex != 0) return NO_SUCH_PAGE; paintComponent(g); return PAGE_EXISTS; }
} class BookComponentPrintable implements Printable {
private Component mComponent; public BookComponentPrintable(Component c) { mComponent = c; } public int print(Graphics g, PageFormat pageFormat, int pageIndex) { Graphics2D g2 = (Graphics2D) g; g2.translate(pageFormat.getImageableX(), pageFormat.getImageableY()); mComponent.paint(g2); return PAGE_EXISTS; }
}
</source>
Book demo
<source lang="java"> import java.awt.BorderLayout; import java.awt.Canvas; import java.awt.Color; import java.awt.Container; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.GridLayout; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.awt.event.MouseMotionAdapter; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.geom.Line2D; import java.awt.geom.Point2D; import java.awt.print.Book; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; import java.util.Vector; import javax.swing.ButtonGroup; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JPanel; import javax.swing.JRadioButton; import javax.swing.border.TitledBorder; public class BookDemo extends JFrame {
DrawingCanvas canvas; JRadioButton portraitButton = new JRadioButton("Portrait", true); JRadioButton landscapeButton = new JRadioButton("Landscape"); JRadioButton rLandscapeButton = new JRadioButton("Reverse Landscape"); JButton addButton = new JButton("Add to Book"); JButton printButton = new JButton("Print"); JButton clearButton = new JButton("Clear"); public BookDemo() { super(); Container container = getContentPane(); canvas = new DrawingCanvas(); container.add(canvas); JPanel panel = new JPanel(new GridLayout(2, 6)); container.add(panel, BorderLayout.SOUTH); ButtonGroup gp = new ButtonGroup(); gp.add(portraitButton); gp.add(landscapeButton); gp.add(rLandscapeButton); ActionListener buttonListener = new ButtonListener(); portraitButton.addActionListener(buttonListener); landscapeButton.addActionListener(buttonListener); rLandscapeButton.addActionListener(buttonListener); panel.add(portraitButton); panel.add(landscapeButton); panel.add(rLandscapeButton); addButton.addActionListener(buttonListener); printButton.addActionListener(buttonListener); clearButton.addActionListener(buttonListener); panel.add(addButton); panel.add(printButton); panel.add(clearButton); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); setSize(450, 425); setVisible(true); } public static void main(String arg[]) { new BookDemo(); } class ButtonListener implements ActionListener { PrinterJob jobControl; PageFormat pageFormat; Book book; ButtonListener() { jobControl = PrinterJob.getPrinterJob(); pageFormat = jobControl.defaultPage(); book = new Book(); } public void actionPerformed(ActionEvent e) { Object obj = e.getSource(); if (obj instanceof JRadioButton) { JRadioButton tempButton = (JRadioButton) obj; if (tempButton.equals(portraitButton)) { pageFormat.setOrientation(PageFormat.PORTRAIT); } else if (tempButton.equals(landscapeButton)) { pageFormat.setOrientation(PageFormat.LANDSCAPE); } else if (tempButton.equals(rLandscapeButton)) { pageFormat.setOrientation(PageFormat.REVERSE_LANDSCAPE); } } else if (obj instanceof JButton) { JButton tempButton = (JButton) obj; if (tempButton.equals(addButton)) { book.append(new PrintableCanvas(canvas.getShapesVector()), (PageFormat) pageFormat.clone()); } else if (tempButton.equals(printButton)) { jobControl.setPageable(book); if (jobControl.printDialog()) { try { jobControl.print(); } catch (Exception pe) { System.out.println("Printing Exception Occured!"); pe.printStackTrace(); } } } else if (tempButton.equals(clearButton)) { canvas.shapesVector.clear(); canvas.clear = true; canvas.repaint(); } } } } class DrawingCanvas extends Canvas { private Vector shapesVector; Point2D currPoint, newPoint; Line2D line; boolean clear = false; DrawingCanvas() { shapesVector = new Vector(); addMouseListener(new MouseHandler()); addMouseMotionListener(new MouseMotionHandler()); setBackground(Color.white); setSize(450, 400); } public Vector getShapesVector() { return shapesVector; } public void update(Graphics g) { Graphics2D g2D = (Graphics2D) g; g2D.setColor(Color.black); if (currPoint != null && newPoint != null) { line = new Line2D.Float(currPoint, newPoint); g2D.draw(line); shapesVector.addElement(line); } currPoint = newPoint; if (clear) { g2D.setColor(Color.white); g2D.fillRect(0, 0, getWidth(), getHeight()); clear = false; } } public void paint(Graphics g) { Graphics2D g2D = (Graphics2D) g; g2D.setColor(Color.black); for (int i = 0; i < shapesVector.size(); i++) { Line2D.Float line2D = (Line2D.Float) shapesVector.elementAt(i); g2D.draw(line2D); } } class MouseHandler extends MouseAdapter { public void mousePressed(MouseEvent e) { currPoint = newPoint = e.getPoint(); repaint(); } } class MouseMotionHandler extends MouseMotionAdapter { public void mouseDragged(MouseEvent e) { newPoint = e.getPoint(); repaint(); } } } class PrintableCanvas implements Printable { private Vector linesVector; public PrintableCanvas(Vector vector) { linesVector = (Vector) vector.clone(); } public int print(Graphics pg, PageFormat pf, int pi) throws PrinterException { Graphics2D pg2D = (Graphics2D) pg; pg2D.translate(pf.getImageableX(), pf.getImageableY()); pg2D.setPaint(Color.green); pg2D.drawString(" ", 100, 100); pg2D.setPaint(Color.black); for (int i = 0; i < linesVector.size(); i++) { Line2D.Float line2D = (Line2D.Float) linesVector.elementAt(i); pg2D.draw(line2D); } return Printable.PAGE_EXISTS; } }
}
</source>
Create PageFormats on a higher level
<source lang="java"> /**
* * JFreeReport : a free Java reporting library * * * Project Info: http://reporting.pentaho.org/ * * (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors. * * This library is free software; you can redistribute it and/or modify it under the terms * of the GNU Lesser General Public License as published by the Free Software Foundation; * either version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License along with this * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, * Boston, MA 02111-1307, USA. * * [Java is a trademark or registered trademark of Sun Microsystems, Inc. * in the United States and other countries.] * * ------------ * PageFormatFactory.java * ------------ * (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors. */
import java.awt.Insets; import java.awt.print.PageFormat; import java.awt.print.Paper; import java.lang.reflect.Field; import sun.rmi.runtime.Log;
/**
* The PageFormatFactory is used to create PageFormats on a higher level. The Factory contains templates for all * PageSizes defined by Adobe: * <p/> * * <p/> * Usage for creating an printjob on A4 paper with 2.5 cm border:*
* Paper paper = PageFormatFactory.createPaper (PageSize.A4); * PageFormatFactory.setBordersMm (paper, 25, 25, 25, 25); * PageFormat format = PageFormatFactory.createPageFormat (paper, PageFormat.PORTRAIT); * </code> * <p/> * Defining a pageformat can be an ugly task and full of dependencies. The call to * PageFormatFactory.setBorders(...) will setup the paper"s border and always assumes * that the paper is laid out in Portrait. * <p/> * Changing the PageFormat"s orientation does not change the PageFormat"s paper object, * but it changes the way, how the paper object is interpreted. * * @author Thomas Morgner */ public final class PageFormatFactory { /** * Constant for dots per inch. * * @deprecated Not used anywhere. */ public static final int DOTS_PER_INCH = 72; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PAPER11X17 = {792, 1224}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PAPER10X11 = {720, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PAPER10X13 = {720, 936}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PAPER10X14 = {720, 1008}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PAPER12X11 = {864, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PAPER15X11 = {1080, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PAPER7X9 = {504, 648}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PAPER8X10 = {576, 720}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PAPER9X11 = {648, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PAPER9X12 = {648, 864}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A0 = {2384, 3370}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A1 = {1684, 2384}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A2 = {1191, 1684}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A3 = {842, 1191}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A3_TRANSVERSE = {842, 1191}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A3_EXTRA = {913, 1262}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A3_EXTRATRANSVERSE = {913, 1262}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A3_ROTATED = {1191, 842}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A4 = {595, 842}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A4_TRANSVERSE = {595, 842}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A4_EXTRA = {667, 914}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A4_PLUS = {595, 936}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A4_ROTATED = {842, 595}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A4_SMALL = {595, 842}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A5 = {420, 595}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A5_TRANSVERSE = {420, 595}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A5_EXTRA = {492, 668}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A5_ROTATED = {595, 420}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A6 = {297, 420}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A6_ROTATED = {420, 297}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A7 = {210, 297}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A8 = {148, 210}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A9 = {105, 148}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] A10 = {73, 105}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ANSIC = {1224, 1584}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ANSID = {1584, 2448}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ANSIE = {2448, 3168}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ARCHA = {648, 864}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ARCHB = {864, 1296}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ARCHC = {1296, 1728}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ARCHD = {1728, 2592}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ARCHE = {2592, 3456}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B0 = {2920, 4127}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B1 = {2064, 2920}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B2 = {1460, 2064}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B3 = {1032, 1460}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B4 = {729, 1032}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B4_ROTATED = {1032, 729}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B5 = {516, 729}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B5_TRANSVERSE = {516, 729}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B5_ROTATED = {729, 516}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B6 = {363, 516}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B6_ROTATED = {516, 363}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B7 = {258, 363}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B8 = {181, 258}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B9 = {127, 181}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] B10 = {91, 127}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] C4 = {649, 918}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] C5 = {459, 649}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] C6 = {323, 459}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] COMM10 = {297, 684}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] DL = {312, 624}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] DOUBLEPOSTCARD = {567, 419}; // should be 419.5, but I ignore that.. /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] DOUBLEPOSTCARD_ROTATED = {419, 567}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENV9 = {279, 639}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENV10 = {297, 684}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENV11 = {324, 747}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENV12 = {342, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENV14 = {360, 828}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVC0 = {2599, 3676}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVC1 = {1837, 2599}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVC2 = {1298, 1837}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVC3 = {918, 1296}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVC4 = {649, 918}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVC5 = {459, 649}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVC6 = {323, 459}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVC65 = {324, 648}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVC7 = {230, 323}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVCHOU3 = {340, 666}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVCHOU3_ROTATED = {666, 340}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVCHOU4 = {255, 581}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVCHOU4_ROTATED = {581, 255}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVDL = {312, 624}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVINVITE = {624, 624}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVISOB4 = {708, 1001}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVISOB5 = {499, 709}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVISOB6 = {499, 354}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVITALIAN = {312, 652}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVELOPE = {312, 652}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVKAKU2 = {680, 941}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVKAKU2_ROTATED = {941, 680}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVKAKU3 = {612, 785}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVKAKU3_ROTATED = {785, 612}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVMONARCH = {279, 540}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPERSONAL = {261, 468}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC1 = {289, 468}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC1_ROTATED = {468, 289}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC2 = {289, 499}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC2_ROTATED = {499, 289}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC3 = {354, 499}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC3_ROTATED = {499, 354}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC4 = {312, 590}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC4_ROTATED = {590, 312}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC5 = {312, 624}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC5_ROTATED = {624, 312}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC6 = {340, 652}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC6_ROTATED = {652, 340}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC7 = {454, 652}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC7_ROTATED = {652, 454}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC8 = {340, 876}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC8_ROTATED = {876, 340}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC9 = {649, 918}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC9_ROTATED = {918, 649}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC10 = {918, 1298}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVPRC10_ROTATED = {1298, 918}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVYOU4 = {298, 666}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ENVYOU4_ROTATED = {666, 298}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] EXECUTIVE = {522, 756}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] FANFOLDUS = {1071, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] FANFOLDGERMAN = {612, 864}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] FANFOLDGERMANLEGAL = {612, 936}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] FOLIO = {595, 935}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB0 = {2835, 4008}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB1 = {2004, 2835}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB2 = {1417, 2004}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB3 = {1001, 1417}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB4 = {709, 1001}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB5 = {499, 709}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB5_EXTRA = {570, 782}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB6 = {354, 499}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB7 = {249, 354}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB8 = {176, 249}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB9 = {125, 176}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] ISOB10 = {88, 125}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] LEDGER = {1224, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] LEGAL = {612, 1008}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] LEGAL_EXTRA = {684, 1080}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] LETTER = {612, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] LETTER_TRANSVERSE = {612, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] LETTER_EXTRA = {684, 864}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] LETTER_EXTRATRANSVERSE = {684, 864}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] LETTER_PLUS = {612, 914}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] LETTER_ROTATED = {792, 612}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] LETTER_SMALL = {612, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] MONARCH = ENVMONARCH; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] NOTE = {612, 792}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] POSTCARD = {284, 419}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] POSTCARD_ROTATED = {419, 284}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PRC16K = {414, 610}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PRC16K_ROTATED = {610, 414}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PRC32K = {275, 428}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PRC32K_ROTATED = {428, 275}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PRC32K_BIG = {275, 428}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] PRC32K_BIGROTATED = {428, 275}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] QUARTO = {610, 780}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] STATEMENT = {396, 612}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] SUPERA = {643, 1009}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] SUPERB = {864, 1380}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] TABLOID = {792, 1224}; /** * A standard paper size. * * @deprecated Using public static arrays is dangerous. */ public static final int[] TABLOIDEXTRA = {864, 1296}; /** * A single instance of the factory. */ private static PageFormatFactory singleton; /** * Default constructor. */ private PageFormatFactory() { } /** * Returns a single instance of the factory. * * @return an instance of a PageFormatFactory. */ public static PageFormatFactory getInstance() { if (singleton == null) { singleton = new PageFormatFactory(); } return singleton; } /** * Creates a paper by using the paper size in points found in the int-array. The array must have a length of 2 and the * first value of this array has to contain the width and the second the height parameter. The created Paper has no * ImagableArea defined. * * @param papersize the definition of the papersize in a 2-element int-array * @return the created paper */ public Paper createPaper(final int[] papersize) { if (papersize.length != 2) { throw new IllegalArgumentException("Paper must have a width and a height"); } return createPaper(papersize[0], papersize[1]); } /** * Creates a paper by using the paper size in points found in the int-array. The array must have a length of 2 and the * first value of this array has to contain the width and the second the height parameter. The created Paper has no * ImagableArea defined. * * @param papersize the definition of the papersize in a 2-element int-array * @return the created paper */ public Paper createPaper(final PageSize papersize) { return createPaper(papersize.getWidth(), papersize.getHeight()); } /** * Creates a paper by using the paper size in points. The created Paper has no ImagableArea defined. * * @param width the width of the paper in points * @param height the height of the paper in points * @return the created paper * @deprecated Use the double version instead. */ public Paper createPaper(final int width, final int height) { return createPaper((double) width, (double) height); } /** * Creates a paper by using the paper size in points. The created Paper has no ImagableArea defined. * * @param width the width of the paper in points * @param height the height of the paper in points * @return the created paper */ public Paper createPaper(final double width, final double height) { final Paper p = new Paper(); p.setSize(width, height); setBorders(p, 0, 0, 0, 0); return p; } /** * Defines the imageable area of the given paper by adjusting the border around the imagable area. The bordersizes are * given in points. * * @param paper the paper that should be modified * @param top the bordersize of the top-border * @param left the border in points in the left * @param bottom the border in points in the bottom * @param right the border in points in the right */ public void setBorders(final Paper paper, final double top, final double left, final double bottom, final double right) { final double w = paper.getWidth() - (right + left); final double h = paper.getHeight() - (bottom + top); paper.setImageableArea(left, top, w, h); } /** * Defines the imageable area of the given paper by adjusting the border around the imagable area. The bordersizes are * given in inches. * * @param paper the paper that should be modified * @param top the bordersize of the top-border * @param left the border in points in the left * @param bottom the border in points in the bottom * @param right the border in points in the right */ public void setBordersInch (final Paper paper, final double top, final double left, final double bottom, final double right) { setBorders(paper, convertInchToPoints(top), convertInchToPoints(left), convertInchToPoints(bottom), convertInchToPoints(right)); } /** * Defines the imageable area of the given paper by adjusting the border around the imagable area. The bordersizes are * given in millimeters. * * @param paper the paper that should be modified * @param top the bordersize of the top-border * @param left the border in points in the left * @param bottom the border in points in the bottom * @param right the border in points in the right */ public void setBordersMm (final Paper paper, final double top, final double left, final double bottom, final double right) { setBorders(paper, convertMmToPoints(top), convertMmToPoints(left), convertMmToPoints(bottom), convertMmToPoints(right)); } /** * Converts the given inch value to a valid point-value. * * @param inches the size in inch * @return the size in points */ public double convertInchToPoints(final double inches) { return inches * 72.0f; } /** * Converts the given millimeter value to a valid point-value. * * @param mm the size in inch * @return the size in points */ public double convertMmToPoints(final double mm) { return mm * (72.0d / 254.0d) * 10; } /** * Creates a new pageformat using the given paper and the given orientation. * * @param paper the paper to use in the new pageformat * @param orientation one of PageFormat.PORTRAIT, PageFormat.LANDSCAPE or PageFormat.REVERSE_LANDSCAPE * @return the created Pageformat * @throws NullPointerException if the paper given was null */ public PageFormat createPageFormat(final Paper paper, final int orientation) { if (paper == null) { throw new NullPointerException("Paper given must not be null"); } final PageFormat pf = new PageFormat(); pf.setPaper(paper); pf.setOrientation(orientation); return pf; } /** * Creates a paper by looking up the given Uppercase name in this classes defined constants. The value if looked up by * introspection, if the value is not defined in this class, null is returned. * * @param name the name of the constant defining the papersize * @return the defined paper or null, if the name was invalid. */ public Paper createPaper(final String name) { try { final Field f = PageSize.class.getDeclaredField(name); final Object o = f.get(null); if (o instanceof PageSize == false) { // Log.debug ("Is no valid pageformat definition"); return null; } final PageSize pageformat = (PageSize) o; return createPaper(pageformat); } catch (NoSuchFieldException nfe) { // Log.debug ("There is no pageformat " + name + " defined."); return null; } catch (IllegalAccessException aie) { // Log.debug ("There is no pageformat " + name + " accessible."); return null; } } /** * Logs the page format. * * @param pf the page format. */ public static void logPageFormat(final PageFormat pf) { System.out.println("PageFormat: Width: " + pf.getWidth() + " Height: " + pf.getHeight()); System.out.println("PageFormat: Image: X " + pf.getImageableX() + " Y " + pf.getImageableY() + " W: " + pf.getImageableWidth() + " H: " + pf.getImageableHeight()); System.out.println("PageFormat: Margins: X " + pf.getImageableX() + " Y " + pf.getImageableY() + " X2: " + (pf.getImageableWidth() + pf.getImageableX()) + " Y2: " + (pf.getImageableHeight() + pf.getImageableY())); } /** * Logs the paper size. * * @param pf the paper size. */ public static void logPaper(final Paper pf) { System.out.println("Paper: Width: " + pf.getWidth() + " Height: " + pf.getHeight()); System.out.println("Paper: Image: X " + pf.getImageableX() + " Y " + pf.getImageableY() + " H: " + pf.getImageableHeight() + " W: " + pf.getImageableWidth()); } /** * Tests, whether the given two page format objects are equal. * * @param pf1 the first page format that should be compared. * @param pf2 the second page format that should be compared. * @return true, if both page formats are equal, false otherwise. */ public static boolean isEqual(final PageFormat pf1, final PageFormat pf2) { if (pf1 == pf2) { return true; } if (pf1 == null || pf2 == null) { return false; } if (pf1.getOrientation() != pf2.getOrientation()) { return false; } final Paper p1 = pf1.getPaper(); final Paper p2 = pf2.getPaper(); if (p1.getWidth() != p2.getWidth()) { return false; } if (p1.getHeight() != p2.getHeight()) { return false; } if (p1.getImageableX() != p2.getImageableX()) { return false; } if (p1.getImageableY() != p2.getImageableY()) { return false; } if (p1.getImageableWidth() != p2.getImageableWidth()) { return false; } if (p1.getImageableHeight() != p2.getImageableHeight()) { return false; } return true; } /** * Returns the left border of the given paper. * * @param p the paper that defines the borders. * @return the left border. */ public double getLeftBorder(final Paper p) { return p.getImageableX(); } /** * Returns the right border of the given paper. * * @param p the paper that defines the borders. * @return the right border. */ public double getRightBorder(final Paper p) { return p.getWidth() - (p.getImageableX() + p.getImageableWidth()); } /** * Returns the top border of the given paper. * * @param p the paper that defines the borders. * @return the top border. */ public double getTopBorder(final Paper p) { return p.getImageableY(); } /** * Returns the bottom border of the given paper. * * @param p the paper that defines the borders. * @return the bottom border. */ public double getBottomBorder(final Paper p) { return p.getHeight() - (p.getImageableY() + p.getImageableHeight()); } /** * Resolves a page format, so that the result can be serialized. * * @param format the page format that should be prepared for serialisation. * @return the prepared page format data. * @deprecated This functionality is part of JCommon-Serializer */ public Object[] resolvePageFormat(final PageFormat format) { final Integer orientation = new Integer(format.getOrientation()); final Paper p = format.getPaper(); final float[] fdim = new float[]{(float) p.getWidth(), (float) p.getHeight()}; final float[] rect = new float[]{(float) p.getImageableX(), (float) p.getImageableY(), (float) p.getImageableWidth(), (float) p.getImageableHeight()}; return new Object[]{orientation, fdim, rect}; } /** * Restores a page format after it has been serialized. * * @param data the serialized page format data. * @return the restored page format. * @deprecated This functionality is part of JCommon-Serializer */ public PageFormat createPageFormat(final Object[] data) { final Integer orientation = (Integer) data[0]; final float[] dim = (float[]) data[1]; final float[] rect = (float[]) data[2]; final Paper p = new Paper(); p.setSize(dim[0], dim[1]); p.setImageableArea(rect[0], rect[1], rect[2], rect[3]); final PageFormat format = new PageFormat(); format.setPaper(p); format.setOrientation(orientation.intValue()); return format; } public Insets getPageMargins (final PageFormat format) { final int marginLeft = (int) format.getImageableX(); final int marginRight = (int) (format.getWidth() - format.getImageableWidth() - format.getImageableX()); final int marginTop = (int) (format.getImageableY()); final int marginBottom = (int) (format.getHeight() - format.getImageableHeight() - format.getImageableY()); return new Insets(marginTop, marginLeft, marginBottom, marginRight); } } /** * * JFreeReport : a free Java reporting library * * * Project Info: http://reporting.pentaho.org/ * * (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors. * * This library is free software; you can redistribute it and/or modify it under the terms * of the GNU Lesser General Public License as published by the Free Software Foundation; * either version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. * See the GNU Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License along with this * library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, * Boston, MA 02111-1307, USA. * * [Java is a trademark or registered trademark of Sun Microsystems, Inc. * in the United States and other countries.] * * ------------ * PageSize.java * ------------ * (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors. */ /** * A class defining a page-dimension. * * @author Thomas Morgner */ final class PageSize { /** * A standard paper size. */ public static final PageSize PAPER11X17 = new PageSize(792, 1224); /** * A standard paper size. */ public static final PageSize PAPER10X11 = new PageSize(720, 792); /** * A standard paper size. */ public static final PageSize PAPER10X13 = new PageSize(720, 936); /** * A standard paper size. */ public static final PageSize PAPER10X14 = new PageSize(720, 1008); /** * A standard paper size. */ public static final PageSize PAPER12X11 = new PageSize(864, 792); /** * A standard paper size. */ public static final PageSize PAPER15X11 = new PageSize(1080, 792); /** * A standard paper size. */ public static final PageSize PAPER7X9 = new PageSize(504, 648); /** * A standard paper size. */ public static final PageSize PAPER8X10 = new PageSize(576, 720); /** * A standard paper size. */ public static final PageSize PAPER9X11 = new PageSize(648, 792); /** * A standard paper size. */ public static final PageSize PAPER9X12 = new PageSize(648, 864); /** * A standard paper size. */ public static final PageSize A0 = new PageSize(2384, 3370); /** * A standard paper size. */ public static final PageSize A1 = new PageSize(1684, 2384); /** * A standard paper size. */ public static final PageSize A2 = new PageSize(1191, 1684); /** * A standard paper size. */ public static final PageSize A3 = new PageSize(842, 1191); /** * A standard paper size. */ public static final PageSize A3_TRANSVERSE = new PageSize(842, 1191); /** * A standard paper size. */ public static final PageSize A3_EXTRA = new PageSize(913, 1262); /** * A standard paper size. */ public static final PageSize A3_EXTRATRANSVERSE = new PageSize(913, 1262); /** * A standard paper size. */ public static final PageSize A3_ROTATED = new PageSize(1191, 842); /** * A standard paper size. */ public static final PageSize A4 = new PageSize(595, 842); /** * A standard paper size. */ public static final PageSize A4_TRANSVERSE = new PageSize(595, 842); /** * A standard paper size. */ public static final PageSize A4_EXTRA = new PageSize(667, 914); /** * A standard paper size. */ public static final PageSize A4_PLUS = new PageSize(595, 936); /** * A standard paper size. */ public static final PageSize A4_ROTATED = new PageSize(842, 595); /** * A standard paper size. */ public static final PageSize A4_SMALL = new PageSize(595, 842); /** * A standard paper size. */ public static final PageSize A5 = new PageSize(420, 595); /** * A standard paper size. */ public static final PageSize A5_TRANSVERSE = new PageSize(420, 595); /** * A standard paper size. */ public static final PageSize A5_EXTRA = new PageSize(492, 668); /** * A standard paper size. */ public static final PageSize A5_ROTATED = new PageSize(595, 420); /** * A standard paper size. */ public static final PageSize A6 = new PageSize(297, 420); /** * A standard paper size. */ public static final PageSize A6_ROTATED = new PageSize(420, 297); /** * A standard paper size. */ public static final PageSize A7 = new PageSize(210, 297); /** * A standard paper size. */ public static final PageSize A8 = new PageSize(148, 210); /** * A standard paper size. */ public static final PageSize A9 = new PageSize(105, 148); /** * A standard paper size. */ public static final PageSize A10 = new PageSize(73, 105); /** * A standard paper size. */ public static final PageSize ANSIC = new PageSize(1224, 1584); /** * A standard paper size. */ public static final PageSize ANSID = new PageSize(1584, 2448); /** * A standard paper size. */ public static final PageSize ANSIE = new PageSize(2448, 3168); /** * A standard paper size. */ public static final PageSize ARCHA = new PageSize(648, 864); /** * A standard paper size. */ public static final PageSize ARCHB = new PageSize(864, 1296); /** * A standard paper size. */ public static final PageSize ARCHC = new PageSize(1296, 1728); /** * A standard paper size. */ public static final PageSize ARCHD = new PageSize(1728, 2592); /** * A standard paper size. */ public static final PageSize ARCHE = new PageSize(2592, 3456); /** * A standard paper size. */ public static final PageSize B0 = new PageSize(2920, 4127); /** * A standard paper size. */ public static final PageSize B1 = new PageSize(2064, 2920); /** * A standard paper size. */ public static final PageSize B2 = new PageSize(1460, 2064); /** * A standard paper size. */ public static final PageSize B3 = new PageSize(1032, 1460); /** * A standard paper size. */ public static final PageSize B4 = new PageSize(729, 1032); /** * A standard paper size. */ public static final PageSize B4_ROTATED = new PageSize(1032, 729); /** * A standard paper size. */ public static final PageSize B5 = new PageSize(516, 729); /** * A standard paper size. */ public static final PageSize B5_TRANSVERSE = new PageSize(516, 729); /** * A standard paper size. */ public static final PageSize B5_ROTATED = new PageSize(729, 516); /** * A standard paper size. */ public static final PageSize B6 = new PageSize(363, 516); /** * A standard paper size. */ public static final PageSize B6_ROTATED = new PageSize(516, 363); /** * A standard paper size. */ public static final PageSize B7 = new PageSize(258, 363); /** * A standard paper size. */ public static final PageSize B8 = new PageSize(181, 258); /** * A standard paper size. */ public static final PageSize B9 = new PageSize(127, 181); /** * A standard paper size. */ public static final PageSize B10 = new PageSize(91, 127); /** * A standard paper size. */ public static final PageSize C4 = new PageSize(649, 918); /** * A standard paper size. */ public static final PageSize C5 = new PageSize(459, 649); /** * A standard paper size. */ public static final PageSize C6 = new PageSize(323, 459); /** * A standard paper size. */ public static final PageSize COMM10 = new PageSize(297, 684); /** * A standard paper size. */ public static final PageSize DL = new PageSize(312, 624); /** * A standard paper size. */ public static final PageSize DOUBLEPOSTCARD = new PageSize(567, 419); // should be 419.5, but I ignore that.. /** * A standard paper size. */ public static final PageSize DOUBLEPOSTCARD_ROTATED = new PageSize(419, 567); /** * A standard paper size. */ public static final PageSize ENV9 = new PageSize(279, 639); /** * A standard paper size. */ public static final PageSize ENV10 = new PageSize(297, 684); /** * A standard paper size. */ public static final PageSize ENV11 = new PageSize(324, 747); /** * A standard paper size. */ public static final PageSize ENV12 = new PageSize(342, 792); /** * A standard paper size. */ public static final PageSize ENV14 = new PageSize(360, 828); /** * A standard paper size. */ public static final PageSize ENVC0 = new PageSize(2599, 3676); /** * A standard paper size. */ public static final PageSize ENVC1 = new PageSize(1837, 2599); /** * A standard paper size. */ public static final PageSize ENVC2 = new PageSize(1298, 1837); /** * A standard paper size. */ public static final PageSize ENVC3 = new PageSize(918, 1296); /** * A standard paper size. */ public static final PageSize ENVC4 = new PageSize(649, 918); /** * A standard paper size. */ public static final PageSize ENVC5 = new PageSize(459, 649); /** * A standard paper size. */ public static final PageSize ENVC6 = new PageSize(323, 459); /** * A standard paper size. */ public static final PageSize ENVC65 = new PageSize(324, 648); /** * A standard paper size. */ public static final PageSize ENVC7 = new PageSize(230, 323); /** * A standard paper size. */ public static final PageSize ENVCHOU3 = new PageSize(340, 666); /** * A standard paper size. */ public static final PageSize ENVCHOU3_ROTATED = new PageSize(666, 340); /** * A standard paper size. */ public static final PageSize ENVCHOU4 = new PageSize(255, 581); /** * A standard paper size. */ public static final PageSize ENVCHOU4_ROTATED = new PageSize(581, 255); /** * A standard paper size. */ public static final PageSize ENVDL = new PageSize(312, 624); /** * A standard paper size. */ public static final PageSize ENVINVITE = new PageSize(624, 624); /** * A standard paper size. */ public static final PageSize ENVISOB4 = new PageSize(708, 1001); /** * A standard paper size. */ public static final PageSize ENVISOB5 = new PageSize(499, 709); /** * A standard paper size. */ public static final PageSize ENVISOB6 = new PageSize(499, 354); /** * A standard paper size. */ public static final PageSize ENVITALIAN = new PageSize(312, 652); /** * A standard paper size. */ public static final PageSize ENVELOPE = new PageSize(312, 652); /** * A standard paper size. */ public static final PageSize ENVKAKU2 = new PageSize(680, 941); /** * A standard paper size. */ public static final PageSize ENVKAKU2_ROTATED = new PageSize(941, 680); /** * A standard paper size. */ public static final PageSize ENVKAKU3 = new PageSize(612, 785); /** * A standard paper size. */ public static final PageSize ENVKAKU3_ROTATED = new PageSize(785, 612); /** * A standard paper size. */ public static final PageSize ENVMONARCH = new PageSize(279, 540); /** * A standard paper size. */ public static final PageSize ENVPERSONAL = new PageSize(261, 468); /** * A standard paper size. */ public static final PageSize ENVPRC1 = new PageSize(289, 468); /** * A standard paper size. */ public static final PageSize ENVPRC1_ROTATED = new PageSize(468, 289); /** * A standard paper size. */ public static final PageSize ENVPRC2 = new PageSize(289, 499); /** * A standard paper size. */ public static final PageSize ENVPRC2_ROTATED = new PageSize(499, 289); /** * A standard paper size. */ public static final PageSize ENVPRC3 = new PageSize(354, 499); /** * A standard paper size. */ public static final PageSize ENVPRC3_ROTATED = new PageSize(499, 354); /** * A standard paper size. */ public static final PageSize ENVPRC4 = new PageSize(312, 590); /** * A standard paper size. */ public static final PageSize ENVPRC4_ROTATED = new PageSize(590, 312); /** * A standard paper size. */ public static final PageSize ENVPRC5 = new PageSize(312, 624); /** * A standard paper size. */ public static final PageSize ENVPRC5_ROTATED = new PageSize(624, 312); /** * A standard paper size. */ public static final PageSize ENVPRC6 = new PageSize(340, 652); /** * A standard paper size. */ public static final PageSize ENVPRC6_ROTATED = new PageSize(652, 340); /** * A standard paper size. */ public static final PageSize ENVPRC7 = new PageSize(454, 652); /** * A standard paper size. */ public static final PageSize ENVPRC7_ROTATED = new PageSize(652, 454); /** * A standard paper size. */ public static final PageSize ENVPRC8 = new PageSize(340, 876); /** * A standard paper size. */ public static final PageSize ENVPRC8_ROTATED = new PageSize(876, 340); /** * A standard paper size. */ public static final PageSize ENVPRC9 = new PageSize(649, 918); /** * A standard paper size. */ public static final PageSize ENVPRC9_ROTATED = new PageSize(918, 649); /** * A standard paper size. */ public static final PageSize ENVPRC10 = new PageSize(918, 1298); /** * A standard paper size. */ public static final PageSize ENVPRC10_ROTATED = new PageSize(1298, 918); /** * A standard paper size. */ public static final PageSize ENVYOU4 = new PageSize(298, 666); /** * A standard paper size. */ public static final PageSize ENVYOU4_ROTATED = new PageSize(666, 298); /** * A standard paper size. */ public static final PageSize EXECUTIVE = new PageSize(522, 756); /** * A standard paper size. */ public static final PageSize FANFOLDUS = new PageSize(1071, 792); /** * A standard paper size. */ public static final PageSize FANFOLDGERMAN = new PageSize(612, 864); /** * A standard paper size. */ public static final PageSize FANFOLDGERMANLEGAL = new PageSize(612, 936); /** * A standard paper size. */ public static final PageSize FOLIO = new PageSize(595, 935); /** * A standard paper size. */ public static final PageSize ISOB0 = new PageSize(2835, 4008); /** * A standard paper size. */ public static final PageSize ISOB1 = new PageSize(2004, 2835); /** * A standard paper size. */ public static final PageSize ISOB2 = new PageSize(1417, 2004); /** * A standard paper size. */ public static final PageSize ISOB3 = new PageSize(1001, 1417); /** * A standard paper size. */ public static final PageSize ISOB4 = new PageSize(709, 1001); /** * A standard paper size. */ public static final PageSize ISOB5 = new PageSize(499, 709); /** * A standard paper size. */ public static final PageSize ISOB5_EXTRA = new PageSize(570, 782); /** * A standard paper size. */ public static final PageSize ISOB6 = new PageSize(354, 499); /** * A standard paper size. */ public static final PageSize ISOB7 = new PageSize(249, 354); /** * A standard paper size. */ public static final PageSize ISOB8 = new PageSize(176, 249); /** * A standard paper size. */ public static final PageSize ISOB9 = new PageSize(125, 176); /** * A standard paper size. */ public static final PageSize ISOB10 = new PageSize(88, 125); /** * A standard paper size. */ public static final PageSize LEDGER = new PageSize(1224, 792); /** * A standard paper size. */ public static final PageSize LEGAL = new PageSize(612, 1008); /** * A standard paper size. */ public static final PageSize LEGAL_EXTRA = new PageSize(684, 1080); /** * A standard paper size. */ public static final PageSize LETTER = new PageSize(612, 792); /** * A standard paper size. */ public static final PageSize LETTER_TRANSVERSE = new PageSize(612, 792); /** * A standard paper size. */ public static final PageSize LETTER_EXTRA = new PageSize(684, 864); /** * A standard paper size. */ public static final PageSize LETTER_EXTRATRANSVERSE = new PageSize(684, 864); /** * A standard paper size. */ public static final PageSize LETTER_PLUS = new PageSize(612, 914); /** * A standard paper size. */ public static final PageSize LETTER_ROTATED = new PageSize(792, 612); /** * A standard paper size. */ public static final PageSize LETTER_SMALL = new PageSize(612, 792); /** * A standard paper size. */ public static final PageSize MONARCH = ENVMONARCH; /** * A standard paper size. */ public static final PageSize NOTE = new PageSize(612, 792); /** * A standard paper size. */ public static final PageSize POSTCARD = new PageSize(284, 419); /** * A standard paper size. */ public static final PageSize POSTCARD_ROTATED = new PageSize(419, 284); /** * A standard paper size. */ public static final PageSize PRC16K = new PageSize(414, 610); /** * A standard paper size. */ public static final PageSize PRC16K_ROTATED = new PageSize(610, 414); /** * A standard paper size. */ public static final PageSize PRC32K = new PageSize(275, 428); /** * A standard paper size. */ public static final PageSize PRC32K_ROTATED = new PageSize(428, 275); /** * A standard paper size. */ public static final PageSize PRC32K_BIG = new PageSize(275, 428); /** * A standard paper size. */ public static final PageSize PRC32K_BIGROTATED = new PageSize(428, 275); /** * A standard paper size. */ public static final PageSize QUARTO = new PageSize(610, 780); /** * A standard paper size. */ public static final PageSize STATEMENT = new PageSize(396, 612); /** * A standard paper size. */ public static final PageSize SUPERA = new PageSize(643, 1009); /** * A standard paper size. */ public static final PageSize SUPERB = new PageSize(864, 1380); /** * A standard paper size. */ public static final PageSize TABLOID = new PageSize(792, 1224); /** * A standard paper size. */ public static final PageSize TABLOIDEXTRA = new PageSize(864, 1296); /** * The width of the page in point. */ private double width; /** * The height of the page in point. */ private double height; /** * Creates a new page-size object with the given width and height. * * @param width the width in point. * @param height the height in point. */ public PageSize(final double width, final double height) { this.width = width; this.height = height; } /** * Returns the page"s width. * * @return the width in point. */ public double getWidth() { return width; } /** * Returns the page"s height. * * @return the height in point. */ public double getHeight() { return height; } /** * Compares this page size with the given object. * * @param o the other object. * @return true, if the given object is also a PageSize object and has the same width and height, false otherwise. */ public boolean equals(final Object o) { if (this == o) { return true; } if (o == null || getClass() != o.getClass()) { return false; } final PageSize pageSize = (PageSize) o; if (equal(pageSize.height, height) == false) { return false; } if (equal(pageSize.width, width) == false) { return false; } return true; } /** * An internal helper method that compares two doubles for equality. * @param d1 the one double. * @param d2 the other double. * @return true, if both doubles are binary equal, false otherwise. */ private boolean equal(final double d1, final double d2) { return Double.doubleToLongBits(d1) == Double.doubleToLongBits(d2); } /** * Computes a hashcode for this page-size. * * @return the hashcode. */ public int hashCode() { long temp = width != +0.0d ? Double.doubleToLongBits(width) : 0L; int result = (int) (temp ^ (temp >>> 32)); temp = height != +0.0d ? Double.doubleToLongBits(height) : 0L; result = 29 * result + (int) (temp ^ (temp >>> 32)); return result; } } </source>Displaying the Page Format Dialog: changes the default page format such as orientation and paper size.
<source lang="java"> import java.awt.print.PageFormat; import java.awt.print.PrinterJob; public class Main {
public static void main(String[] argv) throws Exception { PrinterJob pjob = PrinterJob.getPrinterJob(); PageFormat pf = pjob.defaultPage(); pf.setOrientation(PageFormat.LANDSCAPE); pf = pjob.pageDialog(pf); }}
</source>
Display the print dialog and print
<source lang="java"> import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; public class PrintableDemo1 implements Printable {
public int print(Graphics g, PageFormat pf, int pageIndex) { if (pageIndex != 0) return NO_SUCH_PAGE; Graphics2D g2 = (Graphics2D) g; g2.setFont(new Font("Serif", Font.PLAIN, 36)); g2.setPaint(Color.black); g2.drawString("Java Source and Support!", 144, 144); return PAGE_EXISTS; } public static void main(String[] args) { PrinterJob pj = PrinterJob.getPrinterJob(); pj.setPrintable(new PrintableDemo1()); if (pj.printDialog()) { try { pj.print(); } catch (PrinterException e) { System.out.println(e); } } }}
</source>
Listening for Print Service Status Changes
<source lang="java"> import javax.print.PrintService; import javax.print.PrintServiceLookup; import javax.print.attribute.Attribute; import javax.print.event.PrintServiceAttributeEvent; import javax.print.event.PrintServiceAttributeListener; public class Main {
public static void main(String[] argv) throws Exception { PrintService[] services = PrintServiceLookup.lookupPrintServices(null, null); for (int i = 0; i < services.length; i++) { services[i].addPrintServiceAttributeListener(new MyPrintServiceAttributeListener()); } }} class MyPrintServiceAttributeListener implements PrintServiceAttributeListener {
public void attributeUpdate(PrintServiceAttributeEvent psae) { PrintService service = psae.getPrintService(); Attribute[] attrs = psae.getAttributes().toArray(); for (int i = 0; i < attrs.length; i++) { String attrName = attrs[i].getName(); String attrValue = attrs[i].toString(); } }}
</source>
Overriding the Default Action of a JTextComponent
<source lang="java"> import java.awt.event.ActionEvent; import javax.swing.AbstractAction; import javax.swing.Action; import javax.swing.JTextArea; import javax.swing.text.JTextComponent; import javax.swing.text.Keymap; public class Main {
public static void main(String[] argv) throws Exception { JTextArea component = new JTextArea(); Action defAction = findDefaultAction(component); component.getKeymap().setDefaultAction(new MyDefaultAction(defAction)); } public static Action findDefaultAction(JTextComponent c) { Keymap kmap = c.getKeymap(); if (kmap.getDefaultAction() != null) { return kmap.getDefaultAction(); } kmap = kmap.getResolveParent(); while (kmap != null) { if (kmap.getDefaultAction() != null) { return kmap.getDefaultAction(); } kmap = kmap.getResolveParent(); } return null; }} class MyDefaultAction extends AbstractAction {
Action defAction; public MyDefaultAction(Action a) { super("My Default Action"); defAction = a; } public void actionPerformed(ActionEvent e) { if (e.getActionCommand() != null) { String command = e.getActionCommand(); if (command != null) { command = command.toUpperCase(); } e = new ActionEvent(e.getSource(), e.getID(), command, e.getModifiers()); } if (defAction != null) { defAction.actionPerformed(e); } }}
</source>
Pageable Text
<source lang="java"> /*
* This example is from the book "Java Foundation Classes in a Nutshell". * Written by David Flanagan. Copyright (c) 1999 by O"Reilly & Associates. * You may distribute this source code for non-commercial purposes only. * You may study, modify, and use this example for any purpose, as long as * this notice is retained. Note that this example is provided "as is", * WITHOUT WARRANTY of any kind either expressed or implied. */import java.awt.*; import java.awt.print.*; import java.io.*; import java.util.Vector; public class PageableText implements Pageable, Printable {
// Constants for font name, size, style and line spacing public static String FONTFAMILY = "Monospaced"; public static int FONTSIZE = 10; public static int FONTSTYLE = Font.PLAIN; public static float LINESPACEFACTOR = 1.1f; PageFormat format; // The page size, margins, and orientation Vector lines; // The text to be printed, broken into lines Font font; // The font to print with int linespacing; // How much space between lines int linesPerPage; // How many lines fit on a page int numPages; // How many pages required to print all lines int baseline = -1; // The baseline position of the font. /** Create a PageableText object for a string of text */ public PageableText(String text, PageFormat format) throws IOException { this(new StringReader(text), format); } /** Create a PageableText object for a file of text */ public PageableText(File file, PageFormat format) throws IOException { this(new FileReader(file), format); } /** Create a PageableText object for a stream of text */ public PageableText(Reader stream, PageFormat format) throws IOException { this.format = format; // First, read all the text, breaking it into lines. // This code ignores tabs, and does not wrap long lines. BufferedReader in = new BufferedReader(stream); lines = new Vector(); String line; while((line = in.readLine()) != null) lines.addElement(line); // Create the font we will use, and compute spacing between lines font = new Font(FONTFAMILY, FONTSTYLE, FONTSIZE); linespacing = (int) (FONTSIZE * LINESPACEFACTOR); // Figure out how many lines per page, and how many pages linesPerPage = (int)Math.floor(format.getImageableHeight()/linespacing); numPages = (lines.size()-1)/linesPerPage + 1; } // These are the methods of the Pageable interface. // Note that the getPrintable() method returns this object, which means // that this class must also implement the Printable interface. public int getNumberOfPages() { return numPages; } public PageFormat getPageFormat(int pagenum) { return format; } public Printable getPrintable(int pagenum) { return this; } /** * This is the print() method of the Printable interface. * It does most of the printing work. */ public int print(Graphics g, PageFormat format, int pagenum) { // Tell the PrinterJob if the page number is not a legal one. if ((pagenum < 0) | (pagenum >= numPages)) return NO_SUCH_PAGE; // First time we"re called, figure out the baseline for our font. // We couldn"t do this earlier because we needed a Graphics object if (baseline == -1) { FontMetrics fm = g.getFontMetrics(font); baseline = fm.getAscent(); } // Clear the background to white. This shouldn"t be necessary, but is // required on some systems to workaround an implementation bug g.setColor(Color.white); g.fillRect((int)format.getImageableX(), (int)format.getImageableY(), (int)format.getImageableWidth(), (int)format.getImageableHeight()); // Set the font and the color we will be drawing with. // Note that you cannot assume that black is the default color! g.setFont(font); g.setColor(Color.black); // Figure out which lines of text we will print on this page int startLine = pagenum * linesPerPage; int endLine = startLine + linesPerPage - 1; if (endLine >= lines.size()) endLine = lines.size()-1; // Compute the position on the page of the first line. int x0 = (int) format.getImageableX(); int y0 = (int) format.getImageableY() + baseline; // Loop through the lines, drawing them all to the page. for(int i=startLine; i <= endLine; i++) { // Get the line String line = (String)lines.elementAt(i); // Draw the line. // We use the integer version of drawString(), not the Java 2D // version that uses floating-point coordinates. A bug in early // Java2 implementations prevents the Java 2D version from working. if (line.length() > 0) g.drawString(line, x0, y0); // Move down the page for the next line. y0 += linespacing; } // Tell the PrinterJob that we successfully printed the page. return PAGE_EXISTS; } /** * This is a test program that demonstrates the use of PageableText */ public static void main(String[] args) throws IOException, PrinterException { // Get the PrinterJob object that coordinates everything PrinterJob job = PrinterJob.getPrinterJob(); // Get the default page format, then ask the user to customize it. PageFormat format = job.pageDialog(job.defaultPage()); // Create our PageableText object, and tell the PrinterJob about it job.setPageable(new PageableText(new File(args[0]), format)); // Ask the user to select a printer, etc., and if not canceled, print! if (job.printDialog()) job.print(); }}
</source>
Printable Component
<source lang="java"> /*
* This example is from the book "Java Foundation Classes in a Nutshell". * Written by David Flanagan. Copyright (c) 1999 by O"Reilly & Associates. * You may distribute this source code for non-commercial purposes only. * You may study, modify, and use this example for any purpose, as long as * this notice is retained. Note that this example is provided "as is", * WITHOUT WARRANTY of any kind either expressed or implied. */import java.awt.*; import java.awt.print.*; /**
* This wrapper class encapsulates a Component and allows it to be printed * using the Java 2 printing API. */public class PrintableComponent implements Printable {
// The component to be printed. Component c; /** Create a PrintableComponent wrapper around a Component */ public PrintableComponent(Component c) { this.c = c; } /** * This method is not part of the Printable interface. It is a method * that sets up the PrinterJob and initiates the printing. */ public void print() throws PrinterException { // Get the PrinterJob object PrinterJob job = PrinterJob.getPrinterJob(); // Get the default page format, then allow the user to modify it PageFormat format = job.pageDialog(job.defaultPage()); // Tell the PrinterJob what to print job.setPrintable(this, format); // Ask the user to confirm, and then begin the printing process if (job.printDialog()) job.print(); } /** * This is the "callback" method that the PrinterJob will invoke. * This method is defined by the Printable interface. */ public int print(Graphics g, PageFormat format, int pagenum) { // The PrinterJob will keep trying to print pages until we return // this value to tell it that it has reached the end. if (pagenum > 0) return Printable.NO_SUCH_PAGE; // We"re passed a Graphics object, but it can always be cast to Graphics2D Graphics2D g2 = (Graphics2D) g; // Use the top and left margins specified in the PageFormat Note // that the PageFormat methods are poorly named. They specify // margins, not the actual imageable area of the printer. g2.translate(format.getImageableX(), format.getImageableY()); // Tell the component to draw itself to the printer by passing in // the Graphics2D object. This will not work well if the component // has double-buffering enabled. c.paint(g2); // Return this constant to tell the PrinterJob that we printed the page. return Printable.PAGE_EXISTS; }}
</source>
Printable demo
<source lang="java"> import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.Rectangle2D; import java.awt.print.PageFormat; import java.awt.print.Paper; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; public class PrintableDemo implements Printable {
public int print(Graphics g, PageFormat pf, int pageIndex) { if (pageIndex != 0) return NO_SUCH_PAGE; Graphics2D g2 = (Graphics2D) g; g2.setFont(new Font("Serif", Font.PLAIN, 36)); g2.setPaint(Color.black); g2.drawString("Java Source and Support", 100, 100); Rectangle2D outline = new Rectangle2D.Double(pf.getImageableX(), pf .getImageableY(), pf.getImageableWidth(), pf .getImageableHeight()); g2.draw(outline); return PAGE_EXISTS; } public static void main(String[] args) { PrinterJob pj = PrinterJob.getPrinterJob(); PageFormat pf = pj.defaultPage(); Paper paper = new Paper(); double margin = 36; // half inch paper.setImageableArea(margin, margin, paper.getWidth() - margin * 2, paper.getHeight() - margin * 2); pf.setPaper(paper); pj.setPrintable(new PrintableDemo(), pf); if (pj.printDialog()) { try { pj.print(); } catch (PrinterException e) { System.out.println(e); } } }}
</source>
Printable Document
<source lang="java"> /*
* Copyright (c) 2000 David Flanagan. All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.ru/javaexamples2. */import java.awt.Color; import java.awt.Container; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Rectangle; import java.awt.Shape; import java.awt.font.LineMetrics; import java.awt.geom.Rectangle2D; import java.awt.print.PageFormat; import java.awt.print.Pageable; import java.awt.print.Paper; import java.awt.print.Printable; import java.util.ArrayList; import javax.swing.text.BadLocationException; import javax.swing.text.Document; import javax.swing.text.EditorKit; import javax.swing.text.Element; import javax.swing.text.JTextComponent; import javax.swing.text.Position; import javax.swing.text.View; import javax.swing.text.ViewFactory; import PrintableDocument.ParentView; /**
* This class implements the Pageable and Printable interfaces and allows the * contents of any JTextComponent to be printed using the java.awt.print * printing API. */public class PrintableDocument implements Pageable, Printable {
View root; // The root View to be printed PageFormat format; // Paper plus page orientation int numPages; // How many pages in the document double printX, printY; // coordinates of upper-left of print area double printWidth; // Width of the printable area double printHeight; // Height of the printable area Rectangle drawRect; // The rectangle in which the document is painted // How lenient are we with the bottom margin in widow and orphan prevention? static final double MARGIN_ADJUST = .97; // The font we use for printing page numbers static final Font headerFont = new Font("Serif", Font.PLAIN, 12); /** * This constructor allows printing the contents of any JTextComponent using * a default PageFormat */ public PrintableDocument(JTextComponent textComponent) { this(textComponent, new PageFormat()); } /** * This constructor allows the contents of any JTextComponent to be printed, * using any specified PageFormat object */ public PrintableDocument(JTextComponent textComponent, PageFormat format) { // Remember the page format, and ask it for the printable area this.format = format; this.printX = format.getImageableX(); this.printY = format.getImageableY(); this.printWidth = format.getImageableWidth(); this.printHeight = format.getImageableHeight(); double paperWidth = format.getWidth(); // Get the document and its root Element from the text component Document document = textComponent.getDocument(); Element rootElement = document.getDefaultRootElement(); // Get the EditorKit and its ViewFactory from the text component EditorKit editorKit = textComponent.getUI().getEditorKit(textComponent); ViewFactory viewFactory = editorKit.getViewFactory(); // Use the ViewFactory to create a root View object for the document // This is the object we"ll print. root = viewFactory.create(rootElement); // The Swing text architecture requires us to call setParent() on // our root View before we use it for anything. In order to do this, // we need a View object that can serve as the parent. We use a // custom implementation defined below. root.setParent(new ParentView(root, viewFactory, textComponent)); // Tell the view how wide the page is; it has to format itself // to fit within this width. The height doesn"t really matter here root.setSize((float) printWidth, (float) printHeight); // Now that the view has formatted itself for the specified width, // Ask it how tall it is. double documentHeight = root.getPreferredSpan(View.Y_AXIS); // Set up the rectangle that tells the view where to draw itself // We"ll use it in other methods of this class. drawRect = new Rectangle((int) printX, (int) printY, (int) printWidth, (int) documentHeight); // Now if the document is taller than one page, we have to // figure out where the page breaks are. if (documentHeight > printHeight) paginate(root, drawRect); // Once we"ve broken it into pages, figure out how man pages. numPages = pageLengths.size() + 1; } // This is the starting offset of the page we"re currently working on double pageStart = 0; /** * This method loops through the children of the specified view, recursing * as necessary, and inserts pages breaks when needed. It makes a * rudimentary attempt to avoid "widows" and "orphans". */ protected void paginate(View v, Rectangle2D allocation) { // Figure out how tall this view is, and tell it to allocate // that space among its children double myheight = v.getPreferredSpan(View.Y_AXIS); v.setSize((float) printWidth, (float) myheight); // Now loop through each of the children int numkids = v.getViewCount(); for (int i = 0; i < numkids; i++) { View kid = v.getView(i); // this is the child we"re working with // Figure out its size and location Shape kidshape = v.getChildAllocation(i, allocation); if (kidshape == null) continue; Rectangle2D kidbox = kidshape.getBounds2D(); // This is the Y coordinate of the bottom of the child double kidpos = kidbox.getY() + kidbox.getHeight() - pageStart; // If this is the first child of a group, then we want to ensure // that it doesn"t get left by itself at the bottom of a page. // I.e. we want to prevent "widows" if ((numkids > 1) && (i == 0)) { // If it is not near the end of the page, then just move // on to the next child if (kidpos < printY + printHeight * MARGIN_ADJUST) continue; // Otherwise, the child is near the bottom of the page, so // break the page before this child and place this child on // the new page. breakPage(kidbox.getY()); continue; } // If this is the last child of a group, we don"t want it to // appear by itself at the top of a new page, so allow it to // squeeze past the bottom margin if necessary. This helps to // prevent "orphans" if ((numkids > 1) && (i == numkids - 1)) { // If it fits normally, just move on to the next one if (kidpos < printY + printHeight) continue; // Otherwise, if it fits with extra space, then break the // at the end of the group if (kidpos < printY + printHeight / MARGIN_ADJUST) { breakPage(allocation.getY() + allocation.getHeight()); continue; } } // If the child is not the first or last of a group, then we use // the bottom margin strictly. If the child fits on the page, // then move on to the next child. if (kidpos < printY + printHeight) continue; // If we get here, the child doesn"t fit on this page. If it has // no children, then break the page before this child and continue. if (kid.getViewCount() == 0) { breakPage(kidbox.getY()); continue; } // If we get here, then the child did not fit on the page, but it // has kids of its own, so recurse to see if any of those kids // will fit on the page. paginate(kid, kidbox); } } // For a document of n pages, this list stores the lengths of pages // 0 through n-2. The last page is assumed to have a full length ArrayList pageLengths = new ArrayList(); // For a document of n pages, this list stores the starting offset of // pages 1 through n-1. The offset of page 0 is always 0 ArrayList pageOffsets = new ArrayList(); /** * Break a page at the specified Y coordinate. Store the necessary * information into the pageLengths and pageOffsets lists */ void breakPage(double y) { double pageLength = y - pageStart - printY; pageStart = y - printY; pageLengths.add(new Double(pageLength)); pageOffsets.add(new Double(pageStart)); } /** Return the number of pages. This is a Pageable method. */ public int getNumberOfPages() { return numPages; } /** * Return the PageFormat object for the specified page. This implementation * uses the computed length of the page in the returned PageFormat object. * The PrinterJob will use this as a clipping region, which will prevent * extraneous parts of the document from being drawn in the top and bottom * margins. */ public PageFormat getPageFormat(int pagenum) { // On the last page, just return the user-specified page format if (pagenum == numPages - 1) return format; // Otherwise, look up the height of this page and return an // appropriate PageFormat. double pageLength = ((Double) pageLengths.get(pagenum)).doubleValue(); PageFormat f = (PageFormat) format.clone(); Paper p = f.getPaper(); if (f.getOrientation() == PageFormat.PORTRAIT) p.setImageableArea(printX, printY, printWidth, pageLength); else p.setImageableArea(printY, printX, pageLength, printWidth); f.setPaper(p); return f; } /** * This Printable method returns the Printable object for the specified * page. Since this class implements both Pageable and Printable, it just * returns this. */ public Printable getPrintable(int pagenum) { return this; } /** * This is the basic Printable method that prints a specified page */ public int print(Graphics g, PageFormat format, int pageIndex) { // Return an error code on attempts to print past the end of the doc if (pageIndex >= numPages) return NO_SUCH_PAGE; // Cast the Graphics object so we can use Java2D operations Graphics2D g2 = (Graphics2D) g; // Display a page number centered in the area of the top margin. // Set a new clipping region so we can draw into the top margin // But remember the original clipping region so we can restore it Shape originalClip = g.getClip(); g.setClip(new Rectangle(0, 0, (int) printWidth, (int) printY)); // Compute the header to display, measure it, then display it String numString = "- " + (pageIndex + 1) + " -"; Rectangle2D numBounds = // Get the width and height of the string headerFont.getStringBounds(numString, g2.getFontRenderContext()); LineMetrics metrics = // Get the ascent and descent of the font headerFont.getLineMetrics(numString, g2.getFontRenderContext()); g.setFont(headerFont); // Set the font g.setColor(Color.black); // Print with black ink g.drawString(numString, // Display the string (int) (printX + (printWidth - numBounds.getWidth()) / 2), (int) ((printY - numBounds.getHeight()) / 2 + metrics .getAscent())); g.setClip(originalClip); // Restore the clipping region // Figure out the staring position of the page within the document double pageStart = 0.0; if (pageIndex > 0) pageStart = ((Double) pageOffsets.get(pageIndex - 1)).doubleValue(); // Scroll so that the appropriate part of the document is lined up // with the upper-left corner of the page g2.translate(0.0, -pageStart); // Now paint the entire document. The PrinterJob will have // established a clipping region, so that only the desired portion // of the document will actually be drawn on this sheet of paper. root.paint(g, drawRect); // Finally return a success code return PAGE_EXISTS; } /** * This inner class is a concrete implementation of View, with a couple of * key method implementations. An instance of this class is used as the * parent of the root View object we want to print */ static class ParentView extends View { ViewFactory viewFactory; // The ViewFactory for the hierarchy of views Container container; // The Container for the hierarchy of views public ParentView(View v, ViewFactory viewFactory, Container container) { super(v.getElement()); this.viewFactory = viewFactory; this.container = container; } // These methods return key pieces of information required by // the View hierarchy. public ViewFactory getViewFactory() { return viewFactory; } public Container getContainer() { return container; } // These methods are abstract in View, so we"ve got to provide // dummy implementations of them here, even though they"re never used. public void paint(Graphics g, Shape allocation) { } public float getPreferredSpan(int axis) { return 0.0f; } public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) { return 0; } public Shape modelToView(int pos, Shape a, Position.Bias b) throws BadLocationException { return a; } }}
</source>
Print an Image to print directly
<source lang="java"> import java.io.FileInputStream; import java.io.IOException; import javax.print.Doc; import javax.print.DocFlavor; import javax.print.DocPrintJob; import javax.print.PrintException; import javax.print.PrintService; import javax.print.PrintServiceLookup; import javax.print.SimpleDoc; import javax.print.attribute.HashPrintRequestAttributeSet; import javax.print.attribute.PrintRequestAttributeSet; import javax.print.attribute.standard.Copies; public class PrintImage {
static public void main(String args[]) throws Exception { PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet(); pras.add(new Copies(1)); PrintService pss[] = PrintServiceLookup.lookupPrintServices(DocFlavor.INPUT_STREAM.GIF, pras); if (pss.length == 0) throw new RuntimeException("No printer services available."); PrintService ps = pss[0]; System.out.println("Printing to " + ps); DocPrintJob job = ps.createPrintJob(); FileInputStream fin = new FileInputStream("YOurImageFileName.PNG"); Doc doc = new SimpleDoc(fin, DocFlavor.INPUT_STREAM.GIF, null); job.print(doc, pras); fin.close(); }}
</source>
Print Dialog: change the default printer settings(default printer, number of copies, range of pages)
<source lang="java"> import java.awt.print.PageFormat; import java.awt.print.PrinterJob; public class Main {
public static void main(String[] argv) throws Exception { PrinterJob pjob = PrinterJob.getPrinterJob(); PageFormat pf = pjob.defaultPage(); pjob.setPrintable(null, pf); if (pjob.printDialog()) { pjob.print(); } }}
</source>
PrintFile -- Print a file named on the command line
<source lang="java"> /*
* Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002. * All rights reserved. Software written by Ian F. Darwin and others. * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS"" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s, * pioneering role in inventing and promulgating (and standardizing) the Java * language and environment is gratefully acknowledged. * * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for * inventing predecessor languages C and C++ is also gratefully acknowledged. */import java.awt.*; import java.awt.event.*; import java.io.*; import java.util.*; /**
* PrintFile -- Print a file named on the command line */public class AnotherPrintFile extends Frame {
/** The number of pages to print */ protected static final int NPAGES = 3; /** The actual number of pages */ protected int nPages; /** The PrintJob object */ PrintJob pjob = null; // refers to whole print job /** main program: instantiate and show. */ public static void main(String[] av) { AnotherPrintFile p = new AnotherPrintFile(); p.setVisible(true); if (av.length==0) p.print(new InputStreamReader(System.in)); else for (int i=0; i<av.length; i++) p.print(av[i]); p.setVisible(false); p.dispose(); System.exit(0); } /** Construct a PrintFile object */ AnotherPrintFile() { setLayout(new FlowLayout()); Button b; add(b = new Button("Cancel")); b.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { if (pjob != null) // if quit while printing! pjob.end(); System.exit(0); } }); pack(); } /** Print a file by name */ public void print(String fn) { // open it, call the other guy FileReader ifile = null; try { ifile = new FileReader(fn); } catch (FileNotFoundException fnf) { System.err.println("File not found!"); } print(ifile); } /** Print a file by File */ public void print(Reader ifile) { BufferedReader is = new BufferedReader(ifile); Graphics g = null; // refers to current page System.out.println("Doing print"); pjob = getToolkit().getPrintJob(this, "Printing Test", (Properties)null); if (pjob == null) // User cancelled?? return; Dimension pDim = pjob.getPageDimension(); int pRes = pjob.getPageResolution(); System.out.println("Page size " + pDim + "; Res " + pRes); g = pjob.getGraphics(); g.setColor(Color.black); g.setFont(new Font("SansSerif", Font.PLAIN, 12)); int y = 100; String line; try { while ((line = is.readLine()) != null) { g.drawString(line, 10, y+=18); } } catch (IOException e) { System.err.println(e); } // g.drawString("Page " + pgNum, 300, 300); g.dispose(); // flush page pjob.end(); // total end of print job. pjob = null; // avoid redundant calls to pjob.end() }}
</source>
Print Image
<source lang="java"> 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.SimpleDoc; import javax.print.attribute.HashPrintRequestAttributeSet; import javax.print.attribute.PrintRequestAttributeSet; import javax.print.attribute.standard.Copies; public class Main {
static public void main(String args[]) throws Exception { PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet(); pras.add(new Copies(1)); PrintService pss[] = PrintServiceLookup.lookupPrintServices(DocFlavor.INPUT_STREAM.GIF, pras); PrintService ps = pss[0]; System.out.println("Printing to " + ps); DocPrintJob job = ps.createPrintJob(); FileInputStream fin = new FileInputStream("filename.gif"); Doc doc = new SimpleDoc(fin, DocFlavor.INPUT_STREAM.GIF, null); job.print(doc, pras); fin.close(); }}
</source>
Printing Pages with Different Formats
<source lang="java"> import java.awt.Graphics; import java.awt.print.Book; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; class PrintBook {
public static void main(String[] args) { PrinterJob pjob = PrinterJob.getPrinterJob(); Book book = new Book();PageFormat landscape = pjob.defaultPage(); landscape.setOrientation(PageFormat.LANDSCAPE); book.append(new Printable1(), landscape); PageFormat portrait = pjob.defaultPage(); portrait.setOrientation(PageFormat.PORTRAIT); book.append(new Printable2(), portrait, 5); pjob.setPageable(book); try { pjob.print(); } catch (PrinterException e) { } }} class Printable1 implements Printable {
public int print(Graphics g, PageFormat pf, int pageIndex) { drawGraphics(g, pf); return Printable.PAGE_EXISTS; } public void drawGraphics(Graphics g, PageFormat pf){ }} class Printable2 implements Printable {
public int print(Graphics g, PageFormat pf, int pageIndex) { drawGraphics(g, pf); return Printable.PAGE_EXISTS; } public void drawGraphics(Graphics g, PageFormat pf){ }}
</source>
Printing the Combined-Java 1.2-and-1.4 Way
<source lang="java"> import java.awt.BasicStroke; import java.awt.BorderLayout; import java.awt.Color; import java.awt.ruponent; import java.awt.Container; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.RenderingHints; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.geom.CubicCurve2D; import java.awt.print.PageFormat; import java.awt.print.Printable; import javax.print.Doc; import javax.print.DocFlavor; import javax.print.DocPrintJob; import javax.print.PrintException; import javax.print.PrintService; import javax.print.PrintServiceLookup; 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.swing.JButton; import javax.swing.JFrame; import javax.swing.JPanel; public class PrintingOneTwoFour {
static class MyComponent extends JPanel implements Printable { public void paint(Graphics g) { Graphics2D g2d = (Graphics2D) g; g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON); g2d.setPaint(Color.BLUE); g2d.setStroke(new BasicStroke(3)); CubicCurve2D cubic = new CubicCurve2D.Float(10, 80, 60, 30, 110, 130, 160, 80); g2d.draw(cubic); } public int print(Graphics g, PageFormat pageFormat, int pageIndex) { if (pageIndex == 0) { paint(g); return Printable.PAGE_EXISTS; } else { return Printable.NO_SUCH_PAGE; } } } public static void main(String args[]) throws Exception { final JFrame frame = new JFrame(); Container contentPane = frame.getContentPane(); final Component printIt = new MyComponent(); contentPane.add(printIt, BorderLayout.CENTER); JButton button = new JButton("Print"); contentPane.add(button, BorderLayout.SOUTH); ActionListener listener = new ActionListener() { public void actionPerformed(ActionEvent e) { DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE; PrintService printService = PrintServiceLookup .lookupDefaultPrintService(); DocPrintJob job = printService.createPrintJob(); PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet(); DocAttributeSet das = new HashDocAttributeSet(); Doc doc = new SimpleDoc(printIt, flavor, das); try { job.print(doc, pras); } catch (PrintException pe) { pe.printStackTrace(); } } }; button.addActionListener(listener); frame.setSize(350, 350); frame.show(); }}
</source>
Printing the Java 1.1 Way
<source lang="java"> import java.awt.BorderLayout; import java.awt.ruponent; import java.awt.Container; import java.awt.Graphics; import java.awt.Polygon; import java.awt.PrintJob; import java.awt.Toolkit; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.util.Random; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JPanel; public class PrintingOneOne {
static class MyComponent extends JPanel { Random random = new Random(); public void paint(Graphics g) { Polygon convex, concave, selfintersecting; convex = new Polygon(); convex.addPoint(20, 20); concave = new Polygon(); concave.addPoint(100 + 20, 20); concave.addPoint(100 + 60, 24); selfintersecting = new Polygon(); for (int i = 0; i < 8; i++) { selfintersecting.addPoint(200 + random.nextInt(80), 20 + random .nextInt(80)); } g.fillPolygon(convex); g.drawPolygon(concave); g.fillPolygon(selfintersecting); } } public static void main(String args[]) { final JFrame frame = new JFrame("Printing 1.1"); Container contentPane = frame.getContentPane(); final Component printIt = new MyComponent(); contentPane.add(printIt, BorderLayout.CENTER); JButton button = new JButton("Print"); contentPane.add(button, BorderLayout.SOUTH); ActionListener listener = new ActionListener() { public void actionPerformed(ActionEvent e) { Toolkit def = Toolkit.getDefaultToolkit(); PrintJob job = def.getPrintJob(frame, "Print Job", null); if (job != null) { Graphics pg = job.getGraphics(); printIt.print(pg); pg.dispose(); job.end(); } } }; button.addActionListener(listener); frame.setSize(300, 200); frame.show(); }}
</source>
Printing the Java 1.4 Way
<source lang="java"> 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.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.PrintJobAdapter; import javax.print.event.PrintJobEvent; import javax.print.event.PrintJobListener; public class PrintingOneFour {
public static void main(String args[]) throws Exception { String filename = args[0]; DocFlavor flavor = DocFlavor.INPUT_STREAM.GIF; PrintService printService = PrintServiceLookup .lookupDefaultPrintService(); DocPrintJob job = printService.createPrintJob(); PrintJobListener listener = new PrintJobAdapter() { public void printDataTransferCompleted(PrintJobEvent e) { System.out.println("Good-bye"); System.exit(0); } }; job.addPrintJobListener(listener); PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet(); FileInputStream fis = new FileInputStream(filename); DocAttributeSet das = new HashDocAttributeSet(); Doc doc = new SimpleDoc(fis, flavor, das); job.print(doc, pras); Thread.sleep(10000); }}
</source>
Printing to a File
<source lang="java"> import javax.print.attribute.HashPrintRequestAttributeSet; import javax.print.attribute.PrintRequestAttributeSet; import javax.print.attribute.standard.Destination; public class Main {
public static void main(String[] argv) throws Exception { // Set up destination attribute PrintRequestAttributeSet aset = new HashPrintRequestAttributeSet(); aset.add(new Destination(new java.net.URI("file:e:/temp/out.ps"))); }}
</source>
Print in Java 2: PrinterJob
<source lang="java"> /**
* Class: Example2** * Print in Java series for the JavaWorld magazine. * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 */ import java.awt.BasicStroke; import java.awt.Color; import java.awt.Font; import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.Rectangle2D; import java.awt.print.Book; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterJob; public class JavaWorldPrintExample2 { public static void main(String[] args) { JavaWorldPrintExample2 example2 = new JavaWorldPrintExample2(); System.exit(0); } //--- Private instances declarations private final static int POINTS_PER_INCH = 72; /** * Constructor: Example2 * <p> * */ public JavaWorldPrintExample2() { //--- Create a new PrinterJob object PrinterJob printJob = PrinterJob.getPrinterJob(); //--- Create a new book to add pages to Book book = new Book(); //--- Add the cover page using the default page format for this print // job book.append(new IntroPage(), printJob.defaultPage()); //--- Add the document page using a landscape page format PageFormat documentPageFormat = new PageFormat(); documentPageFormat.setOrientation(PageFormat.LANDSCAPE); book.append(new Document(), documentPageFormat); //--- Tell the printJob to use the book as the pageable object printJob.setPageable(book); //--- Show the print dialog box. If the user click the //--- print button we then proceed to print else we cancel //--- the process. if (printJob.printDialog()) { try { printJob.print(); } catch (Exception PrintException) { PrintException.printStackTrace(); } } } /** * Class: IntroPage * <p> * * This class defines the painter for the cover page by implementing the * Printable interface. * <p> * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */ private class IntroPage implements Printable { /** * Method: print * <p> * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { //--- Create the Graphics2D object Graphics2D g2d = (Graphics2D) g; //--- Translate the origin to 0,0 for the top left corner g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Set the default drawing color to black g2d.setPaint(Color.black); //--- Draw a border arround the page Rectangle2D.Double border = new Rectangle2D.Double(0, 0, pageFormat .getImageableWidth(), pageFormat.getImageableHeight()); g2d.draw(border); //--- Print the title String titleText = "Printing in Java Part 2"; Font titleFont = new Font("helvetica", Font.BOLD, 36); g2d.setFont(titleFont); //--- Compute the horizontal center of the page FontMetrics fontMetrics = g2d.getFontMetrics(); double titleX = (pageFormat.getImageableWidth() / 2) - (fontMetrics.stringWidth(titleText) / 2); double titleY = 3 * POINTS_PER_INCH; g2d.drawString(titleText, (int) titleX, (int) titleY); return (PAGE_EXISTS); } } /** * Class: Document * <p> * * This class is the painter for the document content. * <p> * * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */ private class Document implements Printable { /** * Method: print * <p> * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { //--- Create the Graphics2D object Graphics2D g2d = (Graphics2D) g; //--- Translate the origin to 0,0 for the top left corner g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Set the drawing color to black g2d.setPaint(Color.black); //--- Draw a border arround the page using a 12 point border g2d.setStroke(new BasicStroke(12)); Rectangle2D.Double border = new Rectangle2D.Double(0, 0, pageFormat .getImageableWidth(), pageFormat.getImageableHeight()); g2d.draw(border); //--- Print the text one inch from the top and laft margins g2d.drawString("This the content page", POINTS_PER_INCH, POINTS_PER_INCH); //--- Validate the page return (PAGE_EXISTS); } } } // Example2 </source>
Print in Java 5
<source lang="java"> /**
* Class: Example5 * <p> * * Example of using the TextLayout class to format a text paragraph. with full * justification. * <p> * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 */import java.awt.BasicStroke; import java.awt.Color; import java.awt.Font; import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.font.FontRenderContext; import java.awt.font.LineBreakMeasurer; import java.awt.font.TextAttribute; import java.awt.font.TextLayout; import java.awt.geom.Point2D; import java.awt.geom.Rectangle2D; import java.awt.print.Book; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterJob; import java.text.AttributedString; import java.util.Vector; public class JavaWorldPrintExample5 {
public static void main(String[] args) { JavaWorldPrintExample5 example = new JavaWorldPrintExample5(); System.exit(0); } //--- Private instances declarations private final static int POINTS_PER_INCH = 72; /** * Constructor: Example5 * <p> * */ public JavaWorldPrintExample5() { //--- Create a new PrinterJob object PrinterJob printJob = PrinterJob.getPrinterJob(); //--- Create a new book to add pages to Book book = new Book(); //--- Add the cover page using the default page format for this print // job book.append(new IntroPage(), printJob.defaultPage()); //--- Add the document page using a landscape page format PageFormat documentPageFormat = new PageFormat(); documentPageFormat.setOrientation(PageFormat.LANDSCAPE); book.append(new Document(), documentPageFormat); //--- Tell the printJob to use the book as the pageable object printJob.setPageable(book); //--- Show the print dialog box. If the user click the //--- print button we then proceed to print else we cancel //--- the process. if (printJob.printDialog()) { try { printJob.print(); } catch (Exception PrintException) { PrintException.printStackTrace(); } } } /** * Class: IntroPage * <p> * * This class defines the painter for the cover page by implementing the * Printable interface. * <p> * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */ private class IntroPage implements Printable { /** * Method: print * <p> * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { //--- Create the Graphics2D object Graphics2D g2d = (Graphics2D) g; //--- Translate the origin to 0,0 for the top left corner g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Set the default drawing color to black g2d.setPaint(Color.black); //--- Draw a border arround the page Rectangle2D.Double border = new Rectangle2D.Double(0, 0, pageFormat .getImageableWidth(), pageFormat.getImageableHeight()); g2d.draw(border); //--- Print the title String titleText = "Printing in Java Part 2, Example 5, Using full justification"; Font titleFont = new Font("helvetica", Font.BOLD, 18); g2d.setFont(titleFont); //--- Compute the horizontal center of the page FontMetrics fontMetrics = g2d.getFontMetrics(); double titleX = (pageFormat.getImageableWidth() / 2) - (fontMetrics.stringWidth(titleText) / 2); double titleY = 3 * POINTS_PER_INCH; g2d.drawString(titleText, (int) titleX, (int) titleY); return (PAGE_EXISTS); } } /** * Class: Document * <p> * * This class is the painter for the document content. The print method will * render a text paragraph fully justified. * <p> * * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */ private class Document implements Printable { /** * Method: print * <p> * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { //--- Create the Graphics2D object Graphics2D g2d = (Graphics2D) g; //--- Translate the origin to 0,0 for the top left corner g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Set the drawing color to black g2d.setPaint(Color.black); //--- Draw a border arround the page using a 12 point border g2d.setStroke(new BasicStroke(4)); Rectangle2D.Double border = new Rectangle2D.Double(0, 0, pageFormat .getImageableWidth(), pageFormat.getImageableHeight()); g2d.draw(border); //--- Create a string and assign the text String text = new String(); text += "Manipulating raw fonts would be too complicated to render paragraphs of "; text += "text. Trying to write an algorithm to fully justify text using "; text += "proportional fonts is not trivial. Adding support for international "; text += "characters adds to the complexity. That"s why we will use the "; text += "TextLayout
and theLineBreakMeasurer<code> class to "; text += "render text. The <code>TextLayout<code> class offers a lot of "; text += "functionality to render high quality text. This class is capable of "; text += "rendering bidirectional text such as Japanese text where the alignment "; text += "is from right to left instead of the North American style which is left "; text += "to right. The <code>TextLayout<code> class offers some additional "; text += "functionalities that we will not use in the course of this "; text += "series. Features such as text input, caret positionning and hit "; text += "testing will not be of much use when printing documents, but it"s good "; text += "to know that this functionality exists. "; text += "The <code>TextLayout
class will be used to layout "; text += "paragraphs. TheTextLayout
class does not work alone. To "; text += "layout text within a specified width it needs the help of the "; text += "LineBreakMeasurer
class. This class will wrap a string of "; text += "text to fit a predefined width. Since it"s a multi-lingual class, it "; text += "knows exactly where to break a line of text according to the rules "; text += "of the language. Then again theLineBreakMeasurer
does "; text += "not work alone. It needs information from the "; text += "FontRenderContext
class. This class" main function is to "; text += "return accurate font metrics. To measure text effectively, this class "; text += "needs to know the rendering hints for the targeted device and the font "; text += "type being used. "; //--- Create a point object to set the top left corner of the // TextLayout object Point2D.Double pen = new Point2D.Double(0.25 * POINTS_PER_INCH, 0.25 * POINTS_PER_INCH); //--- Set the width of the TextLayout box double width = 8 * POINTS_PER_INCH; //--- Create an attributed string from the text string. We are // creating an //--- attributed string because the LineBreakMeasurer needs an // Iterator as //--- parameter. AttributedString paragraphText = new AttributedString(text); //--- Set the font for this text paragraphText.addAttribute(TextAttribute.FONT, new Font("serif", Font.PLAIN, 12)); //--- Create a LineBreakMeasurer to wrap the text for the // TextLayout object //--- Note the second parameter, the FontRendereContext. I have set // the second //--- parameter antiAlised to true and the third parameter // useFractionalMetrics //--- to true to get the best possible output LineBreakMeasurer lineBreaker = new LineBreakMeasurer(paragraphText .getIterator(), new FontRenderContext(null, true, true)); //--- Create the TextLayouts object TextLayout layout; TextLayout justifyLayout; //--- Create a Vector to temporaly store each line of text Vector lines = new Vector(); //--- Get the output of the LineBreakMeasurer and store it in a // Vector while ((layout = lineBreaker.nextLayout((float) width)) != null) { lines.add(layout); } //--- Scan each line of the paragraph and justify it except for the // last line for (int i = 0; i < lines.size(); i++) { //--- Get the line from the vector layout = (TextLayout) lines.get(i); //--- Check for the last line. When found print it //--- with justification off if (i != lines.size() - 1) justifyLayout = layout.getJustifiedLayout((float) width); else justifyLayout = layout; //--- Align the Y pen to the ascend of the font, remember that //--- the ascend is origin (0, 0) of a font. Refer to figure 1 pen.y += justifyLayout.getAscent(); //--- Draw the line of text justifyLayout.draw(g2d, (float) pen.x, (float) pen.y); //--- Move the pen to the next position adding the descent and //--- the leading of the font pen.y += justifyLayout.getDescent() + justifyLayout.getLeading(); } //--- Validate the page return (PAGE_EXISTS); } }} // Example5
</source>
Print in Java 6
<source lang="java"> /**
* Class: Example6 * <p> * * Example on how to print an image. * <p> * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 */import java.awt.BasicStroke; import java.awt.Color; import java.awt.ruponent; import java.awt.Font; import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Image; import java.awt.MediaTracker; import java.awt.Toolkit; import java.awt.geom.Rectangle2D; import java.awt.print.Book; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterJob; import java.net.MalformedURLException; import java.net.URL; public class JavaWorldPrintExample6 {
public static void main(String[] args) { JavaWorldPrintExample6 example = new JavaWorldPrintExample6(); System.exit(0); } //--- Private instances declarations private final static int POINTS_PER_INCH = 72; /** * Constructor: Example6 * <p> * */ public JavaWorldPrintExample6() { //--- Create a new PrinterJob object PrinterJob printJob = PrinterJob.getPrinterJob(); //--- Create a new book to add pages to Book book = new Book(); //--- Add the cover page using the default page format for this print // job book.append(new IntroPage(), printJob.defaultPage()); //--- Add the document page using a landscape page format PageFormat documentPageFormat = new PageFormat(); documentPageFormat.setOrientation(PageFormat.LANDSCAPE); book.append(new Document(), documentPageFormat); //--- Tell the printJob to use the book as the pageable object printJob.setPageable(book); //--- Show the print dialog box. If the user click the //--- print button we then proceed to print else we cancel //--- the process. if (printJob.printDialog()) { try { printJob.print(); } catch (Exception PrintException) { PrintException.printStackTrace(); } } } /** * Class: IntroPage * <p> * * This class defines the painter for the cover page by implementing the * Printable interface. * <p> * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */ private class IntroPage implements Printable { /** * Method: print * <p> * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { //--- Create the Graphics2D object Graphics2D g2d = (Graphics2D) g; //--- Translate the origin to 0,0 for the top left corner g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Set the default drawing color to black g2d.setPaint(Color.black); //--- Draw a border arround the page Rectangle2D.Double border = new Rectangle2D.Double(0, 0, pageFormat .getImageableWidth(), pageFormat.getImageableHeight()); g2d.draw(border); //--- Print the title String titleText = "Printing in Java Part 2, Example 6, Printing an image"; Font titleFont = new Font("helvetica", Font.BOLD, 18); g2d.setFont(titleFont); //--- Compute the horizontal center of the page FontMetrics fontMetrics = g2d.getFontMetrics(); double titleX = (pageFormat.getImageableWidth() / 2) - (fontMetrics.stringWidth(titleText) / 2); double titleY = 3 * POINTS_PER_INCH; g2d.drawString(titleText, (int) titleX, (int) titleY); return (PAGE_EXISTS); } } /** * Class: Document * <p> * * This class is the painter for the document content. In this example, it * will print an image of the Nasa Space Station with a border arround it. * <p> * * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */ private class Document extends Component implements Printable { /** * Method: print * <p> * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { //--- Create the Graphics2D object Graphics2D g2d = (Graphics2D) g; //--- Translate the origin to 0,0 for the top left corner g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Set the drawing color to black g2d.setPaint(Color.black); //--- Draw a border arround the page using a 12 point border g2d.setStroke(new BasicStroke(4)); Rectangle2D.Double border = new Rectangle2D.Double(0, 0, pageFormat .getImageableWidth(), pageFormat.getImageableHeight()); g2d.draw(border); //--- Create a media tracker and a URL object MediaTracker mt = new MediaTracker(this); URL imageURL = null; //--- Set the URL to the image that we want to load. //--- NOTE: Change the path to reflect your location of the image //--- NOTE: Only the following image type are supported JPEG, GIF // and PNG. try { imageURL = new URL( "file:///c:/softdev/java/articles/javaworld/printing/part_2/ss2.jpg"); } catch (MalformedURLException me) { me.printStackTrace(); } //--- Load the image and wait for it to load Image image = Toolkit.getDefaultToolkit().getImage(imageURL); mt.addImage(image, 0); try { mt.waitForID(0); } catch (InterruptedException e) { } //--- Render the image on the sheet g2d.drawImage(image, (int) (0.25 * POINTS_PER_INCH), (int) (0.25 * POINTS_PER_INCH), (int) (8.5 * POINTS_PER_INCH), (int) (6 * POINTS_PER_INCH), this); //--- Validate the page return (PAGE_EXISTS); } }} // Example6
</source>
Print in Java: Multi page
<source lang="java"> /**
* Class: Example4 * <p> * * Example of using the TextLayout class to format a text paragraph. * <p> * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 */import java.awt.BasicStroke; import java.awt.Color; import java.awt.Font; import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.font.FontRenderContext; import java.awt.font.LineBreakMeasurer; import java.awt.font.TextAttribute; import java.awt.font.TextLayout; import java.awt.geom.Point2D; import java.awt.geom.Rectangle2D; import java.awt.print.Book; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterJob; import java.text.AttributedString; public class JavaWorldPrintExample4 {
public static void main(String[] args) { JavaWorldPrintExample4 example = new JavaWorldPrintExample4(); System.exit(0); } //--- Private instances declarations private final static int POINTS_PER_INCH = 72; /** * Constructor: Example4 * <p> * */ public JavaWorldPrintExample4() { //--- Create a new PrinterJob object PrinterJob printJob = PrinterJob.getPrinterJob(); //--- Create a new book to add pages to Book book = new Book(); //--- Add the cover page using the default page format for this print // job book.append(new IntroPage(), printJob.defaultPage()); //--- Add the document page using a landscape page format PageFormat documentPageFormat = new PageFormat(); documentPageFormat.setOrientation(PageFormat.LANDSCAPE); book.append(new Document(), documentPageFormat); //--- Tell the printJob to use the book as the pageable object printJob.setPageable(book); //--- Show the print dialog box. If the user click the //--- print button we then proceed to print else we cancel //--- the process. if (printJob.printDialog()) { try { printJob.print(); } catch (Exception PrintException) { PrintException.printStackTrace(); } } } /** * Class: IntroPage * <p> * * This class defines the painter for the cover page by implementing the * Printable interface. * <p> * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */ private class IntroPage implements Printable { /** * Method: print * <p> * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { //--- Create the Graphics2D object Graphics2D g2d = (Graphics2D) g; //--- Translate the origin to 0,0 for the top left corner g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Set the default drawing color to black g2d.setPaint(Color.black); //--- Draw a border arround the page Rectangle2D.Double border = new Rectangle2D.Double(0, 0, pageFormat .getImageableWidth(), pageFormat.getImageableHeight()); g2d.draw(border); //--- Print the title String titleText = "Printing in Java Part 2, Example 4"; Font titleFont = new Font("helvetica", Font.BOLD, 18); g2d.setFont(titleFont); //--- Compute the horizontal center of the page FontMetrics fontMetrics = g2d.getFontMetrics(); double titleX = (pageFormat.getImageableWidth() / 2) - (fontMetrics.stringWidth(titleText) / 2); double titleY = 3 * POINTS_PER_INCH; g2d.drawString(titleText, (int) titleX, (int) titleY); return (PAGE_EXISTS); } } /** * Class: Document * <p> * * This class is the painter for the document content. * <p> * * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */ private class Document implements Printable { /** * Method: print * <p> * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { //--- Create the Graphics2D object Graphics2D g2d = (Graphics2D) g; //--- Translate the origin to 0,0 for the top left corner g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Set the drawing color to black g2d.setPaint(Color.black); //--- Draw a border arround the page using a 12 point border g2d.setStroke(new BasicStroke(4)); Rectangle2D.Double border = new Rectangle2D.Double(0, 0, pageFormat .getImageableWidth(), pageFormat.getImageableHeight()); g2d.draw(border); //--- Create a string and assign the text String text = new String(); text += "Manipulating raw fonts would be too complicated to render paragraphs of "; text += "text. Trying to write an algorithm to fully justify text using "; text += "proportional fonts is not trivial. Adding support for international "; text += "characters adds to the complexity. That"s why we will use the "; text += "TextLayout
and theLineBreakMeasurer<code> class to "; text += "render text. The <code>TextLayout<code> class offers a lot of "; text += "functionality to render high quality text. This class is capable of "; text += "rendering bidirectional text such as Japanese text where the alignment "; text += "is from right to left instead of the North American style which is left "; text += "to right. The <code>TextLayout<code> class offers some additional "; text += "functionalities that we will not use in the course of this "; text += "series. Features such as text input, caret positionning and hit "; text += "testing will not be of much use when printing documents, but it"s good "; text += "to know that this functionality exists. "; text += "The <code>TextLayout
class will be used to layout "; text += "paragraphs. TheTextLayout
class does not work alone. To "; text += "layout text within a specified width it needs the help of the "; text += "LineBreakMeasurer
class. This class will wrap a string of "; text += "text to fit a predefined width. Since it"s a multi-lingual class, it "; text += "knows exactly where to break a line of text according to the rules "; text += "of the language. Then again theLineBreakMeasurer
does "; text += "not work alone. It needs information from the "; text += "FontRenderContext
class. This class" main function is to "; text += "return accurate font metrics. To measure text effectively, this class "; text += "needs to know the rendering hints for the targeted device and the font "; text += "type being used. "; //--- Create a point object to set the top left corner of the // TextLayout object Point2D.Double pen = new Point2D.Double(0.25 * POINTS_PER_INCH, 0.25 * POINTS_PER_INCH); //--- Set the width of the TextLayout box double width = 7.5 * POINTS_PER_INCH; //--- Create an attributed string from the text string. We are // creating an //--- attributed string because the LineBreakMeasurer needs an // Iterator as //--- parameter. AttributedString paragraphText = new AttributedString(text); //--- Set the font for this text paragraphText.addAttribute(TextAttribute.FONT, new Font("serif", Font.PLAIN, 12)); //--- Create a LineBreakMeasurer to wrap the text for the // TextLayout object //--- Note the second parameter, the FontRendereContext. I have set // the second //--- parameter antiAlised to true and the third parameter // useFractionalMetrics //--- to true to get the best possible output LineBreakMeasurer lineBreaker = new LineBreakMeasurer(paragraphText .getIterator(), new FontRenderContext(null, true, true)); //--- Create the TextLayout object TextLayout layout; //--- LineBreakMeasurer will wrap each line to correct length and //--- return it as a TextLayout object while ((layout = lineBreaker.nextLayout((float) width)) != null) { //--- Align the Y pen to the ascend of the font, remember that //--- the ascend is origin (0, 0) of a font. Refer to figure 1 pen.y += layout.getAscent(); //--- Draw the line of text layout.draw(g2d, (float) pen.x, (float) pen.y); //--- Move the pen to the next position adding the descent and //--- the leading of the font pen.y += layout.getDescent() + layout.getLeading(); } //--- Validate the page return (PAGE_EXISTS); } }} // Example4
</source>
Print in Java: page format and document
<source lang="java">
/**
* Class: Example3 * <p> * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 */import java.awt.BasicStroke; import java.awt.Color; import java.awt.Font; import java.awt.FontMetrics; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.Rectangle2D; import java.awt.print.Book; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterJob; public class JavaWorldPrintExample3 {
public static void main(String[] args) { JavaWorldPrintExample3 example3 = new JavaWorldPrintExample3(); System.exit(0); } //--- Private instances declarations private final static int POINTS_PER_INCH = 72; /** * Constructor: Example3 * <p> * */ public JavaWorldPrintExample3() { //--- Create a new PrinterJob object PrinterJob printJob = PrinterJob.getPrinterJob(); //--- Create a new book to add pages to Book book = new Book(); //--- Add the cover page using the default page format for this print // job book.append(new IntroPage(), printJob.defaultPage()); //--- Add the document page using a landscape page format PageFormat documentPageFormat = new PageFormat(); documentPageFormat.setOrientation(PageFormat.LANDSCAPE); book.append(new Document(), documentPageFormat); //--- Add a third page using the same painter book.append(new Document(), documentPageFormat); //--- Tell the printJob to use the book as the pageable object printJob.setPageable(book); //--- Show the print dialog box. If the user click the //--- print button we then proceed to print else we cancel //--- the process. if (printJob.printDialog()) { try { printJob.print(); } catch (Exception PrintException) { PrintException.printStackTrace(); } } } /** * Class: IntroPage * <p> * * This class defines the painter for the cover page by implementing the * Printable interface. * <p> * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */ private class IntroPage implements Printable { /** * Method: print * <p> * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { //--- Create the Graphics2D object Graphics2D g2d = (Graphics2D) g; //--- Translate the origin to 0,0 for the top left corner g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Set the default drawing color to black g2d.setPaint(Color.black); //--- Draw a border arround the page Rectangle2D.Double border = new Rectangle2D.Double(0, 0, pageFormat .getImageableWidth(), pageFormat.getImageableHeight()); g2d.draw(border); //--- Print the title String titleText = "Printing in Java Part 2"; Font titleFont = new Font("helvetica", Font.BOLD, 36); g2d.setFont(titleFont); //--- Compute the horizontal center of the page FontMetrics fontMetrics = g2d.getFontMetrics(); double titleX = (pageFormat.getImageableWidth() / 2) - (fontMetrics.stringWidth(titleText) / 2); double titleY = 3 * POINTS_PER_INCH; g2d.drawString(titleText, (int) titleX, (int) titleY); return (PAGE_EXISTS); } } /** * Class: Document * <p> * * This class is the painter for the document content. * <p> * * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */ private class Document implements Printable { /** * Method: print * <p> * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { //--- Create the Graphics2D object Graphics2D g2d = (Graphics2D) g; //--- Translate the origin to 0,0 for the top left corner g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Set the drawing color to black g2d.setPaint(Color.black); //--- Draw a border arround the page using a 12 point border g2d.setStroke(new BasicStroke(12)); Rectangle2D.Double border = new Rectangle2D.Double(0, 0, pageFormat .getImageableWidth(), pageFormat.getImageableHeight()); g2d.draw(border); //--- Print page 1 if (page == 1) { //--- Print the text one inch from the top and laft margins g2d.drawString("This the content page of page: " + page, POINTS_PER_INCH, POINTS_PER_INCH); return (PAGE_EXISTS); } //--- Print page 2 else if (page == 2) { //--- Print the text one inch from the top and laft margins g2d.drawString("This the content of the second page: " + page, POINTS_PER_INCH, POINTS_PER_INCH); return (PAGE_EXISTS); } //--- Validate the page return (NO_SUCH_PAGE); } }} // Example3
</source>
PrintPanel is the base for an open-ended series of classes
<source lang="java"> /*
* Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002. * All rights reserved. Software written by Ian F. Darwin and others. * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS"" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s, * pioneering role in inventing and promulgating (and standardizing) the Java * language and environment is gratefully acknowledged. * * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for * inventing predecessor languages C and C++ is also gratefully acknowledged. */import java.awt.BorderLayout; import java.awt.Button; import java.awt.CardLayout; import java.awt.Checkbox; import java.awt.Choice; import java.awt.Color; import java.awt.FlowLayout; import java.awt.Frame; import java.awt.GridLayout; import java.awt.Label; import java.awt.Panel; import java.awt.TextField; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.ItemEvent; import java.awt.event.ItemListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; /**
* PrintPanel is the base for an open-ended series of classes that implement * printing of one type. We provide two examples to start: First prints a phone * book, second prints labels, etc. To add more, for example a Mail List/Form * Letter Merge, define a class for it below and insert in the "add" loop in the * main constructor. */abstract class PrintPanel extends Panel {
/** Returns the string to use in a Choice to display this panel */ public abstract String getChoice(); /** Print the data in the format for this type of printout */ public abstract void doPrint();} /**
* PhonesPanel extends PrintPanel to provide the UI for printing a user"s phone * book. */class PhonesPanel extends PrintPanel {
PhonesPanel() { super(); setBackground(Color.red); setLayout(new FlowLayout()); add(new Label("Tab markers at edge of page?")); add(new Checkbox()); add(new Label("Each letter starts page?")); add(new Checkbox()); } public String getChoice() { return "Phone Book"; } public void doPrint() { // code here to print Phone book }} /**
* LabelsPanel extends PrintPanel to provide the UI for printing name and * address labels */class LabelsPanel extends PrintPanel {
LabelsPanel() { super(); setBackground(Color.green); setLayout(new GridLayout(3, 2)); add(new Label("Left Offset:")); add(new TextField(5)); add(new Label("Rows:")); add(new TextField(5)); add(new Label("Cols:")); add(new TextField(5)); } public String getChoice() { return "Labels"; } public void doPrint() { // code here to print Labels }} /**
* CardLayDemo2 -- Prototype of a Print Dialog for JabaDex * * @author Ian F. Darwin * @version 0.0, September, 1996 */public class CardLayDemo2 extends Frame {
PrintPanel[] pps = new PrintPanel[2]; private int runType = 0; private Choice runTypeChoice; private Panel tp, mainP, bp; // top, middle, bottom. CardLayout cardlay; private Button printButton, sampleButton, cancelButton; /** Construct a Print dialog. */ CardLayDemo2(String title) { super(title); // Top panel (tp) has choices for labels/phonebook/etc. // and paper size. // Middle panel (mainP, managed by CardLayout) is details // for either Labels or Phonebook // Shows either a PhonesPanel or a LabelsPanel or ... // Bottom panel (bp) has Print/Preview/Cancel buttons. tp = new Panel(); tp.setLayout(new FlowLayout()); mainP = new Panel(); mainP.setLayout(cardlay = new CardLayout()); tp.add(runTypeChoice = new Choice()); runTypeChoice.addItemListener(new ItemListener() { public void itemStateChanged(ItemEvent e) { runType = runTypeChoice.getSelectedIndex(); cardlay.show(mainP, pps[runType].getChoice()); } }); /* create one instance of each PrintPanel type. */ pps[0] = new PhonesPanel(); pps[1] = new LabelsPanel(); /* Add each print type to the choice and to mainP */ for (int i = 0; i < pps.length; i++) { runTypeChoice.add(pps[i].getChoice()); mainP.add(pps[i].getChoice(), pps[i]); } cardlay.show(mainP, pps[runType].getChoice()); // Bottom has a Panel with push buttons bp = new Panel(); bp.setLayout(new FlowLayout()); bp.add(printButton = new Button("Print")); printButton.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { doPrint(true); setVisible(false); System.exit(0); } }); bp.add(sampleButton = new Button("Print Sample")); sampleButton.setEnabled(false); bp.add(cancelButton = new Button("Cancel")); cancelButton.addActionListener(new ActionListener() { public void actionPerformed(ActionEvent e) { System.out.println("Printing canceled"); setVisible(false); System.exit(0); } }); setLayout(new BorderLayout()); add(tp, BorderLayout.NORTH); add(mainP, BorderLayout.CENTER); add(bp, BorderLayout.SOUTH); pack(); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { // If windowClosing() does setVisible and dispose, // then the close action completes setVisible(false); dispose(); System.exit(0); } }); } /** Print the current list. */ protected void doPrint(boolean toRealDevice) { // open a PrintStream to the printer device to file on disk. // PrintStream pf = ... // call the appropriate doPrint() // pps[runType].doPrint(pf); System.err.println("Print completed"); } public static void main(String[] args) { // Generate some data... // ... // pop up the print dialog to print it (new CardLayDemo2("Print Tester")).setVisible(true); }}
</source>
Print Swing components
<source lang="java"> import java.awt.Color; import java.awt.ruponent; import java.awt.Dimension; import java.awt.Event; import java.awt.Font; import java.awt.GradientPaint; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Paint; import java.awt.Toolkit; import java.awt.event.ActionEvent; import java.awt.event.KeyEvent; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.font.FontRenderContext; import java.awt.font.LineMetrics; import java.awt.geom.Rectangle2D; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; import javax.swing.AbstractAction; import javax.swing.JComponent; import javax.swing.JFrame; import javax.swing.JMenu; import javax.swing.JMenuBar; import javax.swing.KeyStroke; public class SwingPrinter extends JFrame {
public static void main(String[] args) { new SwingPrinter(); } private PageFormat mPageFormat; public SwingPrinter() { super("SwingPrinter v1.0"); createUI(); PrinterJob pj = PrinterJob.getPrinterJob(); mPageFormat = pj.defaultPage(); setVisible(true); } protected void createUI() { setSize(300, 300); center(); // Add the menu bar. JMenuBar mb = new JMenuBar(); JMenu file = new JMenu("File", true); file.add(new FilePrintAction()).setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_P, Event.CTRL_MASK)); file.add(new FilePageSetupAction()).setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_P, Event.CTRL_MASK | Event.SHIFT_MASK)); file.addSeparator(); file.add(new FileQuitAction()).setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_Q, Event.CTRL_MASK)); mb.add(file); setJMenuBar(mb); // Add the contents of the window. getContentPane().add(new PatchworkComponent()); // Exit the application when the window is closed. addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); } protected void center() { Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); Dimension us = getSize(); int x = (screen.width - us.width) / 2; int y = (screen.height - us.height) / 2; setLocation(x, y); } public class FilePrintAction extends AbstractAction { public FilePrintAction() { super("Print"); } public void actionPerformed(ActionEvent ae) { PrinterJob pj = PrinterJob.getPrinterJob(); ComponentPrintable cp = new ComponentPrintable(getContentPane()); pj.setPrintable(cp, mPageFormat); if (pj.printDialog()) { try { pj.print(); } catch (PrinterException e) { System.out.println(e); } } } } public class FilePageSetupAction extends AbstractAction { public FilePageSetupAction() { super("Page setup..."); } public void actionPerformed(ActionEvent ae) { PrinterJob pj = PrinterJob.getPrinterJob(); mPageFormat = pj.pageDialog(mPageFormat); } } public class FileQuitAction extends AbstractAction { public FileQuitAction() { super("Quit"); } public void actionPerformed(ActionEvent ae) { System.exit(0); } }} class PatchworkComponent extends JComponent implements Printable {
private float mSide = 36; private float mOffset = 36; private int mColumns = 8; private int mRows = 4; private String mString = "Java Source and Support"; private Font mFont = new Font("Serif", Font.PLAIN, 64); private Paint mHorizontalGradient, mVerticalGradient; public PatchworkComponent() { float x = mOffset; float y = mOffset; float halfSide = mSide / 2; float x0 = x + halfSide; float y0 = y; float x1 = x + halfSide; float y1 = y + (mRows * mSide); mVerticalGradient = new GradientPaint(x0, y0, Color.darkGray, x1, y1, Color.lightGray, true); x0 = x; y0 = y + halfSide; x1 = x + (mColumns * mSide); y1 = y + halfSide; mHorizontalGradient = new GradientPaint(x0, y0, Color.darkGray, x1, y1, Color.lightGray, true); } public PatchworkComponent(String s) { this(); mString = s; } public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; g2.rotate(Math.PI / 24, mOffset, mOffset); for (int row = 0; row < mRows; row++) { for (int column = 0; column < mColumns; column++) { float x = column * mSide + mOffset; float y = row * mSide + mOffset; if (((column + row) % 2) == 0) g2.setPaint(mVerticalGradient); else g2.setPaint(mHorizontalGradient); Rectangle2D r = new Rectangle2D.Float(x, y, mSide, mSide); g2.fill(r); } } FontRenderContext frc = g2.getFontRenderContext(); float width = (float) mFont.getStringBounds(mString, frc).getWidth(); LineMetrics lm = mFont.getLineMetrics(mString, frc); float x = ((mColumns * mSide) - width) / 2 + mOffset; float y = ((mRows * mSide) + lm.getAscent()) / 2 + mOffset; g2.setFont(mFont); g2.setPaint(Color.white); g2.drawString(mString, x, y); } public int print(Graphics g, PageFormat pageFormat, int pageIndex) { if (pageIndex != 0) return NO_SUCH_PAGE; paintComponent(g); return PAGE_EXISTS; }} class ComponentPrintable implements Printable {
private Component mComponent; public ComponentPrintable(Component c) { mComponent = c; } public int print(Graphics g, PageFormat pageFormat, int pageIndex) { if (pageIndex > 0) return NO_SUCH_PAGE; Graphics2D g2 = (Graphics2D) g; g2.translate(pageFormat.getImageableX(), pageFormat.getImageableY()); boolean wasBuffered = disableDoubleBuffering(mComponent); mComponent.paint(g2); restoreDoubleBuffering(mComponent, wasBuffered); return PAGE_EXISTS; } private boolean disableDoubleBuffering(Component c) { if (c instanceof JComponent == false) return false; JComponent jc = (JComponent) c; boolean wasBuffered = jc.isDoubleBuffered(); jc.setDoubleBuffered(false); return wasBuffered; } private void restoreDoubleBuffering(Component c, boolean wasBuffered) { if (c instanceof JComponent) ((JComponent) c).setDoubleBuffered(wasBuffered); }}
</source>
Print the printable area outline
<source lang="java"> import java.awt.Color; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.Rectangle2D; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; public class OutlinePrintable implements Printable {
public int print(Graphics g, PageFormat pf, int pageIndex) { if (pageIndex != 0) return NO_SUCH_PAGE; Graphics2D g2 = (Graphics2D) g; Rectangle2D outline = new Rectangle2D.Double(pf.getImageableX(), pf .getImageableY(), pf.getImageableWidth(), pf .getImageableHeight()); g2.setPaint(Color.black); g2.draw(outline); return PAGE_EXISTS; } public static void main(String[] args) { PrinterJob pj = PrinterJob.getPrinterJob(); pj.setPrintable(new OutlinePrintable()); if (pj.printDialog()) { try { pj.print(); } catch (PrinterException e) { System.out.println(e); } } }}
</source>
Print the text file and print preview them
<source lang="java"> import java.awt.BorderLayout; import java.awt.Color; import java.awt.Container; import java.awt.Dimension; import java.awt.Event; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.Toolkit; import java.awt.event.ActionEvent; import java.awt.event.KeyEvent; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; import java.io.BufferedReader; import java.io.File; import java.io.FileReader; import java.io.IOException; import java.util.Vector; import javax.swing.AbstractAction; import javax.swing.JComponent; import javax.swing.JFileChooser; import javax.swing.JFrame; import javax.swing.JMenu; import javax.swing.JMenuBar; import javax.swing.JScrollPane; import javax.swing.KeyStroke; public class FilePrinter extends JFrame {
private PageFormat pageFormat; private FilePageRenderer pageRenderer; private String title; public FilePrinter() { super(); init(); PrinterJob pj = PrinterJob.getPrinterJob(); pageFormat = pj.defaultPage(); setVisible(true); } protected void init() { setSize(350, 300); center(); Container content = getContentPane(); content.setLayout(new BorderLayout()); // Add the menu bar. JMenuBar mb = new JMenuBar(); JMenu file = new JMenu("File", true); file.add(new FileOpenAction()).setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_O, Event.CTRL_MASK)); file.add(new FilePrintAction()).setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_P, Event.CTRL_MASK)); file.add(new FilePageSetupAction()).setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_P, Event.CTRL_MASK | Event.SHIFT_MASK)); file.addSeparator(); file.add(new FileQuitAction()).setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_Q, Event.CTRL_MASK)); mb.add(file); JMenu page = new JMenu("Page", true); page.add(new PageNextPageAction()).setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_DOWN, 0)); page.add(new PagePreviousPageAction()).setAccelerator( KeyStroke.getKeyStroke(KeyEvent.VK_PAGE_UP, 0)); mb.add(page); setJMenuBar(mb); getContentPane().setLayout(new BorderLayout()); addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); } protected void center() { Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); Dimension frameSize = getSize(); int x = (screenSize.width - frameSize.width) / 2; int y = (screenSize.height - frameSize.height) / 2; setLocation(x, y); } public void showTitle() { int currentPage = pageRenderer.getCurrentPage() + 1; int numPages = pageRenderer.getNumPages(); setTitle(title + " - page " + currentPage + " of " + numPages); } public class FileOpenAction extends AbstractAction { public FileOpenAction() { super("Open..."); } public void actionPerformed(ActionEvent ae) { // Pop up a file dialog. JFileChooser fc = new JFileChooser("."); int result = fc.showOpenDialog(FilePrinter.this); if (result != 0) { return; } java.io.File f = fc.getSelectedFile(); if (f == null) { return; } // Load the specified file. try { pageRenderer = new FilePageRenderer(f, pageFormat); title = "[" + f.getName() + "]"; showTitle(); JScrollPane jsp = new JScrollPane(pageRenderer); getContentPane().removeAll(); getContentPane().add(jsp, BorderLayout.CENTER); validate(); } catch (java.io.IOException ioe) { System.out.println(ioe); } } } public static void main(String[] args) { new FilePrinter(); } public class FilePrintAction extends AbstractAction { public FilePrintAction() { super("Print"); } public void actionPerformed(ActionEvent ae) { PrinterJob pj = PrinterJob.getPrinterJob(); pj.setPrintable(pageRenderer, pageFormat); if (pj.printDialog()) { try { pj.print(); } catch (PrinterException e) { System.out.println(e); } } } } public class FilePageSetupAction extends AbstractAction { public FilePageSetupAction() { super("Page setup..."); } public void actionPerformed(ActionEvent ae) { PrinterJob pj = PrinterJob.getPrinterJob(); pageFormat = pj.pageDialog(pageFormat); if (pageRenderer != null) { pageRenderer.pageInit(pageFormat); showTitle(); } } } public class FileQuitAction extends AbstractAction { public FileQuitAction() { super("Quit"); } public void actionPerformed(ActionEvent ae) { System.exit(0); } } public class PageNextPageAction extends AbstractAction { public PageNextPageAction() { super("Next page"); } public void actionPerformed(ActionEvent ae) { if (pageRenderer != null) pageRenderer.nextPage(); showTitle(); } } public class PagePreviousPageAction extends AbstractAction { public PagePreviousPageAction() { super("Previous page"); } public void actionPerformed(ActionEvent ae) { if (pageRenderer != null) pageRenderer.previousPage(); showTitle(); } } class FilePageRenderer extends JComponent implements Printable { private int currentPageIndex; private Vector lineVector; private Vector pageVector; private Font font; private int fontSize; private Dimension preferredSize; public FilePageRenderer(File file, PageFormat pageFormat) throws IOException { fontSize = 12; font = new Font("Serif", Font.PLAIN, fontSize); BufferedReader in = new BufferedReader(new FileReader(file)); String line; lineVector = new Vector(); while ((line = in.readLine()) != null) lineVector.addElement(line); in.close(); pageInit(pageFormat); } public void pageInit(PageFormat pageFormat) { currentPageIndex = 0; pageVector = new Vector(); float y = fontSize; Vector page = new Vector(); for (int i = 0; i < lineVector.size(); i++) { String line = (String) lineVector.elementAt(i); page.addElement(line); y += fontSize; if (y + fontSize * 2 > pageFormat.getImageableHeight()) { y = 0; pageVector.addElement(page); page = new Vector(); } } if (page.size() > 0) pageVector.addElement(page); preferredSize = new Dimension((int) pageFormat.getImageableWidth(), (int) pageFormat.getImageableHeight()); repaint(); } public void paintComponent(Graphics g) { Graphics2D g2 = (Graphics2D) g; java.awt.geom.Rectangle2D r = new java.awt.geom.Rectangle2D.Float(0, 0, preferredSize.width, preferredSize.height); g2.setPaint(Color.white); g2.fill(r); Vector page = (Vector) pageVector.elementAt(currentPageIndex); g2.setFont(font); g2.setPaint(Color.black); float x = 0; float y = fontSize; for (int i = 0; i < page.size(); i++) { String line = (String) page.elementAt(i); if (line.length() > 0) g2.drawString(line, (int) x, (int) y); y += fontSize; } } public int print(Graphics g, PageFormat pageFormat, int pageIndex) { if (pageIndex >= pageVector.size()) return NO_SUCH_PAGE; int savedPage = currentPageIndex; currentPageIndex = pageIndex; Graphics2D g2 = (Graphics2D) g; g2.translate(pageFormat.getImageableX(), pageFormat.getImageableY()); paint(g2); currentPageIndex = savedPage; return PAGE_EXISTS; } public Dimension getPreferredSize() { return preferredSize; } public int getCurrentPage() { return currentPageIndex; } public int getNumPages() { return pageVector.size(); } public void nextPage() { if (currentPageIndex < pageVector.size() - 1) currentPageIndex++; repaint(); } public void previousPage() { if (currentPageIndex > 0) currentPageIndex--; repaint(); } }}
</source>
Print to the standard output
<source lang="java"> /*
* Copyright (c) Ian F. Darwin, http://www.darwinsys.ru/, 1996-2002. * All rights reserved. Software written by Ian F. Darwin and others. * $Id: LICENSE,v 1.8 2004/02/09 03:33:38 ian Exp $ * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS"" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. * * Java, the Duke mascot, and all variants of Sun"s Java "steaming coffee * cup" logo are trademarks of Sun Microsystems. Sun"s, and James Gosling"s, * pioneering role in inventing and promulgating (and standardizing) the Java * language and environment is gratefully acknowledged. * * The pioneering role of Dennis Ritchie and Bjarne Stroustrup, of AT&T, for * inventing predecessor languages C and C++ is also gratefully acknowledged. */import java.io.PrintWriter; /** Print to the standard output */ public class PrintStandardOutput {
public static void main(String[] args) { // Just a String to include in printouts. String myAnswer = "No, and that"s final,"; // Print to standard output System.out.println("Hello World of Java"); // Print several things concatendated. System.out.println("The answer is " + myAnswer + " at this time."); // Print to standard output using a Writer PrintWriter pw = new PrintWriter(System.out); pw.println("The answer is " + myAnswer + " at this time."); // Caveat printing ints and chars together int i = 42; pw.println(i + "=" + " the answer."); // WRONG pw.println("Note: " + i + "=" + " the answer."); // OK // Some of the workarounds for the caveat above: pw.println(i + "=" + " the answer."); // using quotes pw.println(i + ("=" + " the answer.")); // parenthesis pw.close(); // If you open it, you close it. }}
</source>
Prompting for a Printer
<source lang="java"> 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.PrintJobAdapter; import javax.print.event.PrintJobEvent; import javax.print.event.PrintJobListener; public class OneFourDialog {
public static void main(String args[]) throws Exception { String filename = args[0]; PrintRequestAttributeSet pras = new HashPrintRequestAttributeSet(); DocFlavor flavor = DocFlavor.INPUT_STREAM.GIF; PrintService printService[] = PrintServiceLookup.lookupPrintServices( flavor, pras); PrintService defaultService = PrintServiceLookup .lookupDefaultPrintService(); PrintService service = ServiceUI.printDialog(null, 200, 200, printService, defaultService, DocFlavor.INPUT_STREAM.GIF, pras); if (service != null) { DocPrintJob job = service.createPrintJob(); PrintJobListener listener = new PrintJobAdapter() { public void printDataTransferCompleted(PrintJobEvent e) { System.exit(0); } }; job.addPrintJobListener(listener); FileInputStream fis = new FileInputStream(filename); DocAttributeSet das = new HashDocAttributeSet(); Doc doc = new SimpleDoc(fis, flavor, das); job.print(doc, pras); Thread.sleep(10000); } }}
</source>
Scribble
<source lang="java"> /*
* Copyright (c) 2000 David Flanagan. All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.ru/javaexamples2. */import java.awt.BorderLayout; import java.awt.Color; import java.awt.ruponent; import java.awt.Container; import java.awt.Dimension; import java.awt.Graphics; import java.awt.event.ActionEvent; import java.awt.event.KeyAdapter; import java.awt.event.KeyEvent; import java.awt.event.MouseAdapter; import java.awt.event.MouseEvent; import java.awt.event.MouseMotionAdapter; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import javax.swing.AbstractAction; import javax.swing.Action; import javax.swing.Icon; import javax.swing.JColorChooser; import javax.swing.JFrame; import javax.swing.JMenu; import javax.swing.JMenuBar; import javax.swing.JOptionPane; import javax.swing.JPanel; import javax.swing.JToolBar; import javax.swing.SwingConstants; import javax.swing.border.BevelBorder; /**
* This JFrame subclass is a simple "paint" application. */public class Scribble extends JFrame {
/** * The main method instantiates an instance of the class, sets it size, and * makes it visible on the screen */ public static void main(String[] args) { Scribble scribble = new Scribble(); scribble.setSize(500, 300); scribble.setVisible(true); } // The scribble application relies on the ScribblePane2 component developed // earlier. This field holds the ScribblePane2 instance it uses. ScribblePane2 scribblePane; /** * This constructor creates the GUI for this application. */ public Scribble() { super("Scribble"); // Call superclass constructor and set window title // Handle window close requests this.addWindowListener(new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } }); // All content of a JFrame (except for the menubar) goes in the // Frame"s internal "content pane", not in the frame itself. // The same is true for JDialog and similar top-level containers. Container contentPane = this.getContentPane(); // Specify a layout manager for the content pane contentPane.setLayout(new BorderLayout()); // Create the main scribble pane component, give it a border, and // a background color, and add it to the content pane scribblePane = new ScribblePane2(); scribblePane.setBorder(new BevelBorder(BevelBorder.LOWERED)); scribblePane.setBackground(Color.white); contentPane.add(scribblePane, BorderLayout.CENTER); // Create a menubar and add it to this window. Note that JFrame // handles menus specially and has a special method for adding them // outside of the content pane. JMenuBar menubar = new JMenuBar(); // Create a menubar this.setJMenuBar(menubar); // Display it in the JFrame // Create menus and add to the menubar JMenu filemenu = new JMenu("File"); JMenu colormenu = new JMenu("Color"); menubar.add(filemenu); menubar.add(colormenu); // Create some Action objects for use in the menus and toolbars. // An Action combines a menu title and/or icon with an ActionListener. // These Action classes are defined as inner classes below. Action clear = new ClearAction(); Action quit = new QuitAction(); Action black = new ColorAction(Color.black); Action red = new ColorAction(Color.red); Action blue = new ColorAction(Color.blue); Action select = new SelectColorAction(); // Populate the menus using Action objects filemenu.add(clear); filemenu.add(quit); colormenu.add(black); colormenu.add(red); colormenu.add(blue); colormenu.add(select); // Now create a toolbar, add actions to it, and add it to the // top of the frame (where it appears underneath the menubar) JToolBar toolbar = new JToolBar(); toolbar.add(clear); toolbar.add(select); toolbar.add(quit); contentPane.add(toolbar, BorderLayout.NORTH); // Create another toolbar for use as a color palette and add to // the left side of the window. JToolBar palette = new JToolBar(); palette.add(black); palette.add(red); palette.add(blue); palette.setOrientation(SwingConstants.VERTICAL); contentPane.add(palette, BorderLayout.WEST); } /** This inner class defines the "clear" action that clears the scribble */ class ClearAction extends AbstractAction { public ClearAction() { super("Clear"); // Specify the name of the action } public void actionPerformed(ActionEvent e) { scribblePane.clear(); } } /** This inner class defines the "quit" action to quit the program */ class QuitAction extends AbstractAction { public QuitAction() { super("Quit"); } public void actionPerformed(ActionEvent e) { // Use JOptionPane to confirm that the user really wants to quit int response = JOptionPane.showConfirmDialog(Scribble.this, "Really Quit?"); if (response == JOptionPane.YES_OPTION) System.exit(0); } } /** * This inner class defines an Action that sets the current drawing color of * the ScribblePane2 component. Note that actions of this type have icons * rather than labels */ class ColorAction extends AbstractAction { Color color; public ColorAction(Color color) { this.color = color; putValue(Action.SMALL_ICON, new ColorIcon(color)); // specify icon } public void actionPerformed(ActionEvent e) { scribblePane.setColor(color); // Set current drawing color } } /** * This inner class implements Icon to draw a solid 16x16 block of the * specified color. Most icons are instances of ImageIcon, but since we"re * only using solid colors here, it is easier to implement this custom Icon * type */ static class ColorIcon implements Icon { Color color; public ColorIcon(Color color) { this.color = color; } // These two methods specify the size of the icon public int getIconHeight() { return 16; } public int getIconWidth() { return 16; } // This method draws the icon public void paintIcon(Component c, Graphics g, int x, int y) { g.setColor(color); g.fillRect(x, y, 16, 16); } } /** * This inner class defines an Action that uses JColorChooser to allow the * user to select a drawing color */ class SelectColorAction extends AbstractAction { public SelectColorAction() { super("Select Color..."); } public void actionPerformed(ActionEvent e) { Color color = JColorChooser.showDialog(Scribble.this, "Select Drawing Color", scribblePane.getColor()); if (color != null) scribblePane.setColor(color); } }} /*
* Copyright (c) 2000 David Flanagan. All rights reserved. This code is from the * book Java Examples in a Nutshell, 2nd Edition. It is provided AS-IS, WITHOUT * ANY WARRANTY either expressed or implied. You may study, use, and modify it * for any non-commercial purpose. You may distribute it non-commercially as * long as you retain this notice. For a commercial use license, or to purchase * the book (recommended), visit http://www.davidflanagan.ru/javaexamples2. *//**
* A simple JPanel subclass that uses event listeners to allow the user to * scribble with the mouse. Note that scribbles are not saved or redrawn. */class ScribblePane2 extends JPanel {
public ScribblePane2() { // Give the component a preferred size setPreferredSize(new Dimension(450, 200)); // Register a mouse event handler defined as an inner class // Note the call to requestFocus(). This is required in order for // the component to receive key events. addMouseListener(new MouseAdapter() { public void mousePressed(MouseEvent e) { moveto(e.getX(), e.getY()); // Move to click position requestFocus(); // Take keyboard focus } }); // Register a mouse motion event handler defined as an inner class // By subclassing MouseMotionAdapter rather than implementing // MouseMotionListener, we only override the method we"re interested // in and inherit default (empty) implementations of the other methods. addMouseMotionListener(new MouseMotionAdapter() { public void mouseDragged(MouseEvent e) { lineto(e.getX(), e.getY()); // Draw to mouse position } }); // Add a keyboard event handler to clear the screen on key "C" addKeyListener(new KeyAdapter() { public void keyPressed(KeyEvent e) { if (e.getKeyCode() == KeyEvent.VK_C) clear(); } }); } /** These are the coordinates of the the previous mouse position */ protected int last_x, last_y; /** Remember the specified point */ public void moveto(int x, int y) { last_x = x; last_y = y; } /** Draw from the last point to this point, then remember new point */ public void lineto(int x, int y) { Graphics g = getGraphics(); // Get the object to draw with g.setColor(color); // Tell it what color to use g.drawLine(last_x, last_y, x, y); // Tell it what to draw moveto(x, y); // Save the current point } /** * Clear the drawing area, using the component background color. This method * works by requesting that the component be redrawn. Since this component * does not have a paintComponent() method, nothing will be drawn. However, * other parts of the component, such as borders or sub-components will be * drawn correctly. */ public void clear() { repaint(); } /** This field holds the current drawing color property */ Color color = Color.black; /** This is the property "setter" method for the color property */ public void setColor(Color color) { this.color = color; } /** This is the property "getter" method for the color property */ public Color getColor() { return color; }}
</source>
Setting the Orientation of a Printed Page
<source lang="java"> import java.awt.print.PageFormat; import java.awt.print.PrinterJob; public class Main {
public static void main(String[] argv) throws Exception { PrinterJob pjob = PrinterJob.getPrinterJob(); PageFormat pf = pjob.defaultPage(); pf.setOrientation(PageFormat.PORTRAIT); pf.setOrientation(PageFormat.LANDSCAPE); // pjob.setPrintable(printable, pf); pjob.print(); }}
</source>
Shapes Print
<source lang="java"> import java.awt.BorderLayout; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; import java.awt.geom.RoundRectangle2D; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JPanel; public class ShapesPrint extends JPanel implements Printable, ActionListener {
final static JButton button = new JButton("Print"); public ShapesPrint() { button.addActionListener(this); } public void actionPerformed(ActionEvent e) { if (e.getSource() instanceof JButton) { PrinterJob printJob = PrinterJob.getPrinterJob(); printJob.setPrintable(this); if (printJob.printDialog()) { try { printJob.print(); } catch (Exception ex) { ex.printStackTrace(); } } } } public void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2 = (Graphics2D) g; drawShapes(g2); } public void drawShapes(Graphics2D g2) { g2.fill(new RoundRectangle2D.Double(10, 10, 200, 200, 10, 10)); } public int print(Graphics g, PageFormat pf, int pi) throws PrinterException { if (pi >= 1) { return Printable.NO_SUCH_PAGE; } drawShapes((Graphics2D) g); return Printable.PAGE_EXISTS; } public static void main(String s[]) { WindowListener l = new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } public void windowClosed(WindowEvent e) { System.exit(0); } }; JFrame f = new JFrame(); f.addWindowListener(l); JPanel panel = new JPanel(); panel.add(button); f.getContentPane().add(BorderLayout.SOUTH, panel); f.getContentPane().add(BorderLayout.CENTER, new ShapesPrint()); f.setSize(580, 500); f.show(); }}
</source>
Simple Book for printing
<source lang="java"> import java.awt.BorderLayout; import java.awt.Color; import java.awt.Font; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.event.ActionEvent; import java.awt.event.ActionListener; import java.awt.event.WindowAdapter; import java.awt.event.WindowEvent; import java.awt.event.WindowListener; import java.awt.geom.RoundRectangle2D; import java.awt.print.Book; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; import javax.swing.JButton; import javax.swing.JFrame; import javax.swing.JPanel; public class SimpleBook extends JPanel implements ActionListener {
final static JButton button = new JButton("Print"); public SimpleBook() { button.addActionListener(this); } public void actionPerformed(ActionEvent e) { PrinterJob job = PrinterJob.getPrinterJob(); PageFormat landscape = job.defaultPage(); landscape.setOrientation(PageFormat.LANDSCAPE); Book bk = new Book(); bk.append(new DefaultPage(), job.defaultPage()); bk.append(new PaintContent(), landscape); job.setPageable(bk); if (job.printDialog()) { try { job.print(); } catch (Exception exc) { } } } public void paintComponent(Graphics g) { super.paintComponent(g); Graphics2D g2 = (Graphics2D) g; drawShapes(g2); } static void drawShapes(Graphics2D g2) { g2.fill(new RoundRectangle2D.Double(10, 10, 200, 200, 10, 10)); } public static void main(String[] args) { WindowListener l = new WindowAdapter() { public void windowClosing(WindowEvent e) { System.exit(0); } public void windowClosed(WindowEvent e) { System.exit(0); } }; JFrame f = new JFrame(); f.addWindowListener(l); JPanel panel = new JPanel(); panel.add(button); f.getContentPane().add(BorderLayout.SOUTH, panel); f.getContentPane().add(BorderLayout.CENTER, new SimpleBook()); f.setSize(775, 450); f.show(); }} class DefaultPage implements Printable {
Font fnt = new Font("Helvetica-Bold", Font.PLAIN, 48); public int print(Graphics g, PageFormat pf, int pageIndex) throws PrinterException { g.setFont(fnt); g.setColor(Color.black); g.drawString("Sample Shapes", 100, 200); return Printable.PAGE_EXISTS; }} class PaintContent implements Printable {
public int print(Graphics g, PageFormat pf, int pageIndex) throws PrinterException { SimpleBook.drawShapes((Graphics2D) g); return Printable.PAGE_EXISTS; }}
</source>
Simplest SWT Print Example
<source lang="java"> /**
* Class: Example1 * <p> * * @author Jean-Pierre Dube <jpdube@videotron.ca> * @version 1.0 * @since 1.0 * @see Printable */import java.awt.Color; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.Line2D; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterJob; public class JavaWorldPrintExample1 implements Printable {
public static void main(String[] args) { JavaWorldPrintExample1 example1 = new JavaWorldPrintExample1(); System.exit(0); } //--- Private instances declarations private final double INCH = 72; /** * Constructor: Example1 * <p> * */ public JavaWorldPrintExample1() { //--- Create a printerJob object PrinterJob printJob = PrinterJob.getPrinterJob(); //--- Set the printable class to this one since we //--- are implementing the Printable interface printJob.setPrintable(this); //--- Show a print dialog to the user. If the user //--- click the print button, then print otherwise //--- cancel the print job if (printJob.printDialog()) { try { printJob.print(); } catch (Exception PrintException) { PrintException.printStackTrace(); } } } /** * Method: print * <p> * * This class is responsible for rendering a page using the provided * parameters. The result will be a grid where each cell will be half an * inch by half an inch. * * @param g * a value of type Graphics * @param pageFormat * a value of type PageFormat * @param page * a value of type int * @return a value of type int */ public int print(Graphics g, PageFormat pageFormat, int page) { int i; Graphics2D g2d; Line2D.Double line = new Line2D.Double(); //--- Validate the page number, we only print the first page if (page == 0) { //--- Create a graphic2D object a set the default parameters g2d = (Graphics2D) g; g2d.setColor(Color.black); //--- Translate the origin to be (0,0) g2d.translate(pageFormat.getImageableX(), pageFormat .getImageableY()); //--- Print the vertical lines for (i = 0; i < pageFormat.getWidth(); i += INCH / 2) { line.setLine(i, 0, i, pageFormat.getHeight()); g2d.draw(line); } //--- Print the horizontal lines for (i = 0; i < pageFormat.getHeight(); i += INCH / 2) { line.setLine(0, i, pageFormat.getWidth(), i); g2d.draw(line); } return (PAGE_EXISTS); } else return (NO_SUCH_PAGE); }} //Example1
</source>
The area of the actual page
<source lang="java"> import java.awt.Graphics; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; import javax.swing.JComponent; public class BasicPrint extends JComponent implements Printable {
public int print(Graphics g, PageFormat pf, int pageIndex) { double x = 0; double y = 0; double w = pf.getWidth(); double h = pf.getHeight(); return Printable.NO_SUCH_PAGE; } public static void main(String[] args) { PrinterJob pjob = PrinterJob.getPrinterJob(); PageFormat pf = pjob.defaultPage(); pjob.setPrintable(new BasicPrint(), pf); try { pjob.print(); } catch (PrinterException e) { } }}
</source>
The area of the printable area
<source lang="java"> import java.awt.Graphics; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; import javax.swing.JComponent; public class BasicPrint extends JComponent implements Printable {
public int print(Graphics g, PageFormat pf, int pageIndex) { double ix = pf.getImageableX(); double iy = pf.getImageableY(); double iw = pf.getImageableWidth(); double ih = pf.getImageableHeight(); return Printable.NO_SUCH_PAGE; } public static void main(String[] args) { PrinterJob pjob = PrinterJob.getPrinterJob(); PageFormat pf = pjob.defaultPage(); pjob.setPrintable(new BasicPrint(), pf); try { pjob.print(); } catch (PrinterException e) { } }}
</source>
The Printing code which implements Printable
<source lang="java"> import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.print.PageFormat; import java.awt.print.Printable; import java.awt.print.PrinterException; import java.awt.print.PrinterJob; import javax.swing.JComponent; public class BasicPrint extends JComponent implements Printable {
public int print(Graphics g, PageFormat pf, int pageIndex) { if (pageIndex > 0) { return Printable.NO_SUCH_PAGE; } Graphics2D g2d = (Graphics2D) g; g2d.translate(pf.getImageableX(), pf.getImageableY()); drawGraphics(g2d, pf); return Printable.PAGE_EXISTS; } public void drawGraphics(Graphics2D g2d,PageFormat pf){ } public static void main(String[] args) { PrinterJob pjob = PrinterJob.getPrinterJob(); PageFormat pf = pjob.defaultPage(); pjob.setPrintable(new BasicPrint(), pf); try { pjob.print(); } catch (PrinterException e) { } }}
</source>