/*
 * 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.com/javaexamples2.
 */
package com.davidflanagan.examples.print;
import java.awt.*;
import java.awt.event.*;
import java.awt.print.*;
import java.awt.geom.*;
import javax.swing.*;
import java.util.*;

/** 
 * A "scribble" application that remembers the scribble and allows the user
 * to print it.  It displays a Swing API and uses the Java 1.2 printing API.
 * It also uses Java2D features to draw and represent the scribble.
 **/
public class ScribblePrinter2 extends JComponent implements Printable {
    Stroke linestyle = new BasicStroke(3.0f); // Draw with wide lines
    GeneralPath scribble = new GeneralPath(); // Holds the scribble

    public ScribblePrinter2() {
	// Register event types we're interested in for scribbling
	enableEvents(AWTEvent.MOUSE_EVENT_MASK |
		     AWTEvent.MOUSE_MOTION_EVENT_MASK);

	// Add a print button to he layout, and respond to it by printing
	JButton b = new JButton("Print");
	b.addActionListener(new ActionListener() {
		public void actionPerformed(ActionEvent e) { printScribble(); }
	    });
	this.setLayout(new FlowLayout(FlowLayout.LEFT, 5, 5));
	this.add(b);
    }
    
    /** Redraw (or print) the scribble based on stored lines */
    public void paintComponent(Graphics g) {
	super.paintComponent(g);   // Allow the superclass to draw itself
	Graphics2D g2 = (Graphics2D) g;
	g2.setStroke(linestyle);   // Specify wide lines
	g2.draw(scribble);         // Draw the scribble
    }
    
    /**
     * Print out the scribble.  This is the method invoked by the Print button;
     * it is not part of the Printable interface
     **/
    public void printScribble() {
	// Obtain a java.awt.print.PrinterJob  (not java.awt.PrintJob)
	PrinterJob job = PrinterJob.getPrinterJob();

	// Tell the PrinterJob to print us (since we implement Printable)
	// using the default page layout
	job.setPrintable(this, job.defaultPage());

	// Display the print dialog that allows the user to set options.
	// The method returns false if the user cancelled the print request
	if (job.printDialog()) {
	    // If not cancelled, start printing!  This will call the print()
	    // method defined by the Printable interface.
	    try { job.print(); }
	    catch (PrinterException e) { System.err.println(e);  }
	}
    }

    /**
     * This is the method defined by the Printable interface.  It prints the
     * scribble to the specified Graphics object, respecting the paper size
     * and margins specified by the PageFormat.  If the specified page number
     * is not page 0, it returns a code saying that printing is complete.  The
     * method must be prepared to be called multiple times per printing request
     **/
    public int print(Graphics g, PageFormat format, int pagenum) {
	// We are only one page long; reject any other page numbers
	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 = this.getSize();                  // Scribble size
	double pageWidth = format.getImageableWidth();    // Page width
	double pageHeight = format.getImageableHeight();  // Page height

	// If the scribble 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 scribble 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
	g2.drawRect(-1, -1, size.width+2, size.height+2);
	
	// Set a clipping region so the scribbles don't go out of bounds
	g2.setClip(0, 0, size.width, size.height);

	// Finally, print the component by calling the paintComponent() method.
	// Or, call paint() to paint the component, its background, border, and
	// children, including the Print JButton
	this.paintComponent(g);

	// Tell the PrinterJob that the page number was valid
	return Printable.PAGE_EXISTS;
    }
    
    /** Called when the user clicks to begin a scribble */
    public void processMouseEvent(MouseEvent e) {
	if (e.getID() == MouseEvent.MOUSE_PRESSED) {
	    scribble.moveTo(e.getX(), e.getY());  // Start a new line 
	}
	else super.processMouseEvent(e);
    }
    
    /** Called when the the user drags the mouse: does the scribbling */
    public void processMouseMotionEvent(MouseEvent e) {
	if (e.getID() == MouseEvent.MOUSE_DRAGGED) {
	    scribble.lineTo(e.getX(), e.getY());  // Add a line to the scribble
	    repaint();  // Redraw the whole scribble. Clean but a little slow
	}
	else super.processMouseMotionEvent(e);
    }
    
    /** The main method.  Create a ScribblePrinter2 object and away we go! */
    public static void main(String[] args) {
	JFrame frame = new JFrame("ScribblePrinter2");
	ScribblePrinter2 s = new ScribblePrinter2();
	frame.getContentPane().add(s, BorderLayout.CENTER);
	frame.setSize(400, 400);
	frame.setVisible(true);
    }
}