/* * 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.print.*;import java.awt.geom.*;import java.awt.font.*;import javax.swing.*;import javax.swing.text.*;import java.util.*;/** * 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    double scalefactor;     // How much to scale before printing    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/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 and a default scale factor.  The default     * scale factor is .75 because the default fonts are overly large.     */    public PrintableDocument(JTextComponent textComponent) {	this(textComponent, new PageFormat(), .75);    }    /**      * This constructor allows the contents of any JTextComponent to be     * printed, using any specified PageFormat object and any scaling factor.     **/    public PrintableDocument(JTextComponent textComponent, PageFormat format,			     double scalefactor)    {	// Remember the page format, and ask it for the printable area	this.format = format;	this.scalefactor = scalefactor;	this.printX = format.getImageableX()/scalefactor;	this.printY = format.getImageableY()/scalefactor;	this.printWidth = format.getImageableWidth()/scalefactor;	this.printHeight = format.getImageableHeight()/scalefactor;	double paperWidth = format.getWidth()/scalefactor;	// 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(0, 0, (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 many 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		// page 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 is a     * Pageable method. 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*scalefactor, printY*scalefactor,			       printWidth*scalefactor, pageLength*scalefactor);	else 	    p.setImageableArea(printY*scalefactor, printX*scalefactor,			       pageLength*scalefactor, printWidth*scalefactor);	f.setPaper(p);	return f;    }    /**     * This Pageable 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;		// Translate to accomodate the top and left margins	g2.translate(format.getImageableX(), format.getImageableY());		// Scale the page by the specified scaling factor	g2.scale(scalefactor, scalefactor);	// 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	if (pageIndex > 0) {	    Shape originalClip = g.getClip();	    g.setClip(new Rectangle(0, (int)-printY,				    (int)printWidth, (int)printY));	    // Compute the header to display, measure it, then display it	    String numString = "- " + (pageIndex+1) + " -";	    // Get string and font measurements	    FontRenderContext frc = g2.getFontRenderContext();	    Rectangle2D numBounds = headerFont.getStringBounds(numString, frc);	    LineMetrics metrics = headerFont.getLineMetrics(numString, frc);	    g.setFont(headerFont);    // Set the font	    g.setColor(Color.black);  // Print with black ink	    g.drawString(numString,   // Display the string			 (int)((printWidth-numBounds.getWidth())/2),			 (int)(-(printY-numBounds.getHeight())/2 +			       metrics.getAscent()));	    g.setClip(originalClip);  // Restore the clipping region	}	// Get the staring position and length of the page within the document	double pageStart = 0.0, pageLength = printHeight;	if (pageIndex > 0)	    pageStart = ((Double)pageOffsets.get(pageIndex-1)).doubleValue();	if (pageIndex < numPages-1)	    pageLength = ((Double)pageLengths.get(pageIndex)).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.  Because of the clipping region,	// 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;	}    }}