package weichang;


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+1, (int)documentHeight+1);

        // 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();
            g2.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);
            g2.setFont(headerFont);    // Set the font
            g2.setColor(Color.black);  // Print with black ink
            g2.drawString(numString,   // Display the string
                         (int)((printWidth-numBounds.getWidth())/2),
                         (int)(-(printY-numBounds.getHeight())/2 +
                               metrics.getAscent()));
            g2.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(g2, drawRect);

        // Finally return a success code
        return PAGE_EXISTS;
    }
    public void jobprint(){
      PrinterJob job=PrinterJob.getPrinterJob();
      job.setPrintable(this,job.defaultPage());
      if(job.printDialog()){
        try {
          job.print();
        }
        catch (PrinterException ex) {
        }
      }

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