Mega Code Archive
Demonstrate the Java 1 4 printing API
<![CDATA[
/*
* Copyright (c) 2004 David Flanagan. All rights reserved.
* This code is from the book Java Examples in a Nutshell, 3nd 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,
* including teaching and use in open-source projects.
* You may distribute it non-commercially as long as you retain this notice.
* For a commercial use license, or to purchase the book,
* please visit http://www.davidflanagan.com/javaexamples3.
*/
//package je3.print;
import java.awt.Component;
import java.awt.Dimension;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.JobAttributes;
import java.awt.PageAttributes;
import java.awt.PrintJob;
import java.awt.Toolkit;
import java.awt.image.BufferedImage;
import java.awt.print.PageFormat;
import java.awt.print.Printable;
import java.awt.print.PrinterException;
import java.awt.print.PrinterJob;
import java.io.File;
import java.io.FileOutputStream;
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.ServiceUI;
import javax.print.SimpleDoc;
import javax.print.StreamPrintService;
import javax.print.StreamPrintServiceFactory;
import javax.print.attribute.HashPrintRequestAttributeSet;
import javax.print.attribute.PrintRequestAttributeSet;
import javax.print.attribute.standard.Chromaticity;
import javax.print.attribute.standard.OrientationRequested;
import javax.print.event.PrintJobAdapter;
import javax.print.event.PrintJobEvent;
import javax.swing.JComponent;
import javax.swing.JDialog;
import javax.swing.JFileChooser;
import javax.swing.JOptionPane;
/**
* This class extends JuliaSet2 and its print() and save() methods demonstrate
* the Java 1.4 printing API.
*/
public class JuliaSet3 extends JuliaSet2 {
public JuliaSet3() {
super(-.7, -.25);
}
// This method overrides JuliaSet2.print() and demonstrates the javax.print
// printing API.
public void print() {
// Get a list of all printers that can handle Printable objects.
DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE;
PrintService[] services = PrintServiceLookup.lookupPrintServices(flavor, null);
// Set some define printing attributes
PrintRequestAttributeSet printAttributes = new HashPrintRequestAttributeSet();
printAttributes.add(OrientationRequested.LANDSCAPE); // landscape mode
printAttributes.add(Chromaticity.MONOCHROME); // print in mono
// Display a dialog that allows the user to select one of the
// available printers and to edit the default attributes
PrintService service = ServiceUI.printDialog(null, 100, 100, services, null, null,
printAttributes);
// If the user canceled, don't do anything
if (service == null)
return;
// Now call a method defined below to finish the printing
printToService(service, printAttributes);
}
// This method is like print() above but prints to a PostScript file
// instead of printing to a printer.
public void save() throws IOException {
// Find a factory object for printing Printable objects to PostScript.
DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE;
String format = "application/postscript";
StreamPrintServiceFactory factory = StreamPrintServiceFactory
.lookupStreamPrintServiceFactories(flavor, format)[0];
// Ask the user to select a file and open the selected file
JFileChooser chooser = new JFileChooser();
if (chooser.showSaveDialog(this) != JFileChooser.APPROVE_OPTION)
return;
File f = chooser.getSelectedFile();
FileOutputStream out = new FileOutputStream(f);
// Obtain a PrintService that prints to that file
StreamPrintService service = factory.getPrintService(out);
// Do the printing with the method below
printToService(service, null);
// And close the output file.
out.close();
}
// Print the Julia set to the sepecifed PrintService using the specified
// attributes.
public void printToService(PrintService service, PrintRequestAttributeSet printAttributes) {
// Wrap ourselves in the PrintableComponent class defined by JuliaSet2.
String title = "Julia set for c={" + cx + "," + cy + "}";
Printable printable = new PrintableComponent(this, title);
// Now create a Doc that encapsulate the Printable object and its type
DocFlavor flavor = DocFlavor.SERVICE_FORMATTED.PRINTABLE;
Doc doc = new SimpleDoc(printable, flavor, null);
// Java 1.1 uses PrintJob.
// Java 1.2 uses PrinterJob.
// Java 1.4 uses DocPrintJob. Create one from the service
DocPrintJob job = service.createPrintJob();
// Set up a dialog box to monitor printing status
final JOptionPane pane = new JOptionPane("Printing...", JOptionPane.PLAIN_MESSAGE);
JDialog dialog = pane.createDialog(this, "Print Status");
// This listener object updates the dialog as the status changes
job.addPrintJobListener(new PrintJobAdapter() {
public void printJobCompleted(PrintJobEvent e) {
pane.setMessage("Printing complete.");
}
public void printDataTransferCompleted(PrintJobEvent e) {
pane.setMessage("Document transfered to printer.");
}
public void printJobRequiresAttention(PrintJobEvent e) {
pane.setMessage("Check printer: out of paper?");
}
public void printJobFailed(PrintJobEvent e) {
pane.setMessage("Print job failed");
}
});
// Show the dialog, non-modal.
dialog.setModal(false);
dialog.show();
// Now print the Doc to the DocPrintJob
try {
job.print(doc, printAttributes);
} catch (PrintException e) {
// Display any errors to the dialog box
pane.setMessage(e.toString());
}
}
}
class JuliaSet2 extends JuliaSet1 {
public JuliaSet2() {
this(.4, .4);
} // Display a different set by default
public JuliaSet2(double cx, double cy) {
super(cx, cy);
}
// This method demonstrates the Java 1.2 printing API.
// Test it using the ShowBean program.
public void print() {
// Java 1.1 used java.awt.PrintJob.
// In Java 1.2 we use java.awt.print.PrinterJob
PrinterJob job = PrinterJob.getPrinterJob();
// Alter the default page settings to request landscape mode
PageFormat page = job.defaultPage();
page.setOrientation(PageFormat.LANDSCAPE); // landscape by default
// Tell the PrinterJob what Printable object we want to print.
// PrintableComponent is defined as an inner class below
String title = "Julia set for c={" + cx + "," + cy + "}";
Printable printable = new PrintableComponent(this, title);
job.setPrintable(printable, page);
// Call the printDialog() method to give the user a chance to alter
// the printing attributes or to cancel the printing request.
if (job.printDialog()) {
// If we get here, then the user did not cancel the print job
// So start printing, displaying a dialog for errors.
try {
job.print();
} catch (PrinterException e) {
JOptionPane.showMessageDialog(this, e.toString(), "PrinterException",
JOptionPane.ERROR_MESSAGE);
}
}
}
// This inner class implements the Printable interface for an AWT component
public static class PrintableComponent implements Printable {
Component c;
String title;
public PrintableComponent(Component c, String title) {
this.c = c;
this.title = title;
}
// This method should print the specified page number to the specified
// Graphics object, abiding by the specified page format.
// The printing system will call this method repeatedly to print all
// pages of the print job. If pagenum is greater than the last page,
// it should return NO_SUCH_PAGE to indicate that it is done. The
// printing system may call this method multiple times per page.
public int print(Graphics g, PageFormat format, int pagenum) {
// This implemenation is always a single page
if (pagenum > 0)
return Printable.NO_SUCH_PAGE;
// The Java 1.2 printing API passes us a Graphics object, but we
// can always cast it to a Graphics2D object
Graphics2D g2 = (Graphics2D) g;
// Translate to accomodate the requested top and left margins.
g2.translate(format.getImageableX(), format.getImageableY());
// Figure out how big the drawing is, and how big the page
// (excluding margins) is
Dimension size = c.getSize(); // component size
double pageWidth = format.getImageableWidth(); // Page width
double pageHeight = format.getImageableHeight(); // Page height
// If the component is too wide or tall for the page, scale it down
if (size.width > pageWidth) {
double factor = pageWidth / size.width; // How much to scale
g2.scale(factor, factor); // Adjust coordinate system
pageWidth /= factor; // Adjust page size up
pageHeight /= factor;
}
if (size.height > pageHeight) { // Do the same thing for height
double factor = pageHeight / size.height;
g2.scale(factor, factor);
pageWidth /= factor;
pageHeight /= factor;
}
// Now we know the component will fit on the page. Center it by
// translating as necessary.
g2.translate((pageWidth - size.width) / 2, (pageHeight - size.height) / 2);
// Draw a line around the outside of the drawing area and label it
g2.drawRect(-1, -1, size.width + 2, size.height + 2);
g2.drawString(title, 0, -15);
// Set a clipping region so the component can't draw outside of
// its won bounds.
g2.setClip(0, 0, size.width, size.height);
// Finally, print the component by calling its paint() method.
// This prints the background, border, and children as well.
// For swing components, if you don't want the background, border,
// and children, then call printComponent() instead.
c.paint(g);
// Tell the PrinterJob that the page number was valid
return Printable.PAGE_EXISTS;
}
}
}
class JuliaSet1 extends JComponent {
// These constants are hard-coded for simplicity
double x1 = -1.5, y1 = -1.5, x2 = 1.5, y2 = 1.5; // Region of complex plane
int width = 400, height = 400; // Mapped to these pixels
double cx, cy; // This complex constant defines the set we display
BufferedImage image; // The image we compute
// We compute values between 0 and 63 for each point in the complex plane.
// This array holds the color values for each of those values.
static int[] colors;
static { // Static initializer for the colors[] array.
colors = new int[64];
for (int i = 0; i < colors.length; i++) {
colors[63 - i] = (i * 4 << 16) + (i * 4 << 8) + i * 4; // grayscale
// (i*4) ^ ((i * 3)<<6) ^ ((i * 7)<<13); // crazy technicolor
}
}
// No-arg constructor with default values for cx, cy.
public JuliaSet1() {
this(-1, 0);
}
// This constructor specifies the {cx,cy} constant.
// For simplicity, the other constants remain hardcoded.
public JuliaSet1(double cx, double cy) {
this.cx = cx;
this.cy = cy;
setPreferredSize(new Dimension(width, height));
computeImage();
}
// This method computes a color value for each pixel of the image
void computeImage() {
// Create the image
image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
// Now loop through the pixels
int i, j;
double x, y;
double dx = (x2 - x1) / width;
double dy = (y2 - y1) / height;
for (j = 0, y = y1; j < height; j++, y += dy) {
for (i = 0, x = x1; i < width; i++, x += dx) {
// For each pixel, call testPoint() to determine a value.
// Then map that value to a color and set it in the image.
// If testPoint() returns 0, the point is part of the Julia set
// and is displayed in black. If it returns 63, the point is
// displayed in white. Values in-between are displayed in
// varying shades of gray.
image.setRGB(i, j, colors[testPoint(x, y)]);
}
}
}
// This is the key method for computing Julia sets. For each point z
// in the complex plane, we repeatedly compute z = z*z + c using complex
// arithmetic. We stop iterating when the magnitude of z exceeds 2 or
// after 64 iterations. We return the number of iterations-1.
public int testPoint(double zx, double zy) {
for (int i = 0; i < colors.length; i++) {
// Compute z = z*z + c;
double newx = zx * zx - zy * zy + cx;
double newy = 2 * zx * zy + cy;
zx = newx;
zy = newy;
// Check magnitude of z and return iteration number
if (zx * zx + zy * zy > 4)
return i;
}
return colors.length - 1;
}
// This method overrides JComponent to display the julia set.
// Just scale the image to fit and draw it.
public void paintComponent(Graphics g) {
g.drawImage(image, 0, 0, getWidth(), getHeight(), this);
}
// This method demonstrates the Java 1.1 java.awt.PrintJob printing API.
// It also demonstrates the JobAttributes and PageAttributes classes
// added in Java 1.3. Display the Julia set with ShowBean and use
// the Command menu to invoke this print command.
public void print() {
// Create some attributes objects. This is Java 1.3 stuff.
// In Java 1.1, we'd use a java.util.Preferences object instead.
JobAttributes jattrs = new JobAttributes();
PageAttributes pattrs = new PageAttributes();
// Set some example attributes: monochrome, landscape mode
pattrs.setColor(PageAttributes.ColorType.MONOCHROME);
pattrs.setOrientationRequested(PageAttributes.OrientationRequestedType.LANDSCAPE);
// Print to file by default
jattrs.setDestination(JobAttributes.DestinationType.FILE);
jattrs.setFileName("juliaset.ps");
// Look up the Frame that holds this component
Component frame = this;
while (!(frame instanceof Frame))
frame = frame.getParent();
// Get a PrintJob object to print the Julia set with.
// The getPrintJob() method displays a print dialog and allows the user
// to override and modify the default JobAttributes and PageAttributes
Toolkit toolkit = this.getToolkit();
PrintJob job = toolkit.getPrintJob((Frame) frame, "JuliaSet1", jattrs, pattrs);
// We get a null PrintJob if the user clicked cancel
if (job == null)
return;
// Get a Graphics object from the PrintJob.
// We print simply by drawing to this Graphics object.
Graphics g = job.getGraphics();
// Center the image on the page
Dimension pagesize = job.getPageDimension(); // how big is page?
Dimension panesize = this.getSize(); // how big is image?
g.translate((pagesize.width - panesize.width) / 2, // center it
(pagesize.height - panesize.height) / 2);
// Draw a box around the Julia Set and label it
g.drawRect(-1, -1, panesize.width + 2, panesize.height + 2);
g.drawString("Julia Set for c={" + cx + "," + cy + "}", 0, -15);
// Set a clipping region
g.setClip(0, 0, panesize.width, panesize.height);
// Now print the component by calling its paint method
this.paint(g);
// Finally tell the printer we're done with the page.
// No output will be generated if we don't call dispose() here.
g.dispose();
}
}
]]>