ojluni/src/main/java/javax/swing/TablePrintable.java - platform/libcore.git - Git at Google

 /*
  * Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.  Oracle designates this
  * particular file as subject to the "Classpath" exception as provided
  * by Oracle in the LICENSE file that accompanied this code.
  *
  * This code 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 General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 package javax.swing;

 import javax.swing.table.*;
 import java.awt.*;
 import java.awt.print.*;
 import java.awt.geom.*;
 import java.text.MessageFormat;

 /**
  * An implementation of <code>Printable</code> for printing
  * <code>JTable</code>s.
  * <p>
  * This implementation spreads table rows naturally in sequence
  * across multiple pages, fitting as many rows as possible per page.
  * The distribution of columns, on the other hand, is controlled by a
  * printing mode parameter passed to the constructor. When
  * <code>JTable.PrintMode.NORMAL</code> is used, the implementation
  * handles columns in a similar manner to how it handles rows, spreading them
  * across multiple pages (in an order consistent with the table's
  * <code>ComponentOrientation</code>).
  * When <code>JTable.PrintMode.FIT_WIDTH</code> is given, the implementation
  * scales the output smaller if necessary, to ensure that all columns fit on
  * the page. (Note that width and height are scaled equally, ensuring that the
  * aspect ratio remains the same).
  * <p>
  * The portion of table printed on each page is headed by the
  * appropriate section of the table's <code>JTableHeader</code>.
  * <p>
  * Header and footer text can be added to the output by providing
  * <code>MessageFormat</code> instances to the constructor. The
  * printing code requests Strings from the formats by calling
  * their <code>format</code> method with a single parameter:
  * an <code>Object</code> array containing a single element of type
  * <code>Integer</code>, representing the current page number.
  * <p>
  * There are certain circumstances where this <code>Printable</code>
  * cannot fit items appropriately, resulting in clipped output.
  * These are:
  * <ul>
  *   <li>In any mode, when the header or footer text is too wide to
  *       fit completely in the printable area. The implementation
  *       prints as much of the text as possible starting from the beginning,
  *       as determined by the table's <code>ComponentOrientation</code>.
  *   <li>In any mode, when a row is too tall to fit in the
  *       printable area. The upper most portion of the row
  *       is printed and no lower border is shown.
  *   <li>In <code>JTable.PrintMode.NORMAL</code> when a column
  *       is too wide to fit in the printable area. The center of the
  *       column is printed and no left and right borders are shown.
  * </ul>
  * <p>
  * It is entirely valid for a developer to wrap this <code>Printable</code>
  * inside another in order to create complex reports and documents. They may
  * even request that different pages be rendered into different sized
  * printable areas. The implementation was designed to handle this by
  * performing most of its calculations on the fly. However, providing different
  * sizes works best when <code>JTable.PrintMode.FIT_WIDTH</code> is used, or
  * when only the printable width is changed between pages. This is because when
  * it is printing a set of rows in <code>JTable.PrintMode.NORMAL</code> and the
  * implementation determines a need to distribute columns across pages,
  * it assumes that all of those rows will fit on each subsequent page needed
  * to fit the columns.
  * <p>
  * It is the responsibility of the developer to ensure that the table is not
  * modified in any way after this <code>Printable</code> is created (invalid
  * modifications include changes in: size, renderers, or underlying data).
  * The behavior of this <code>Printable</code> is undefined if the table is
  * changed at any time after creation.
  *
  * @author  Shannon Hickey
  */
 class TablePrintable implements Printable {

     /** The table to print. */
     private JTable table;

     /** For quick reference to the table's header. */
     private JTableHeader header;

     /** For quick reference to the table's column model. */
     private TableColumnModel colModel;

     /** To save multiple calculations of total column width. */
     private int totalColWidth;

     /** The printing mode of this printable. */
     private JTable.PrintMode printMode;

     /** Provides the header text for the table. */
     private MessageFormat headerFormat;

     /** Provides the footer text for the table. */
     private MessageFormat footerFormat;

     /** The most recent page index asked to print. */
     private int last = -1;

     /** The next row to print. */
     private int row = 0;

     /** The next column to print. */
     private int col = 0;

     /** Used to store an area of the table to be printed. */
     private final Rectangle clip = new Rectangle(0, 0, 0, 0);

     /** Used to store an area of the table's header to be printed. */
     private final Rectangle hclip = new Rectangle(0, 0, 0, 0);

     /** Saves the creation of multiple rectangles. */
     private final Rectangle tempRect = new Rectangle(0, 0, 0, 0);

     /** Vertical space to leave between table and header/footer text. */
     private static final int H_F_SPACE = 8;

     /** Font size for the header text. */
     private static final float HEADER_FONT_SIZE = 18.0f;

     /** Font size for the footer text. */
     private static final float FOOTER_FONT_SIZE = 12.0f;

     /** The font to use in rendering header text. */
     private Font headerFont;

     /** The font to use in rendering footer text. */
     private Font footerFont;

     /**
      * Create a new <code>TablePrintable</code> for the given
      * <code>JTable</code>. Header and footer text can be specified using the
      * two <code>MessageFormat</code> parameters. When called upon to provide
      * a String, each format is given the current page number.
      *
      * @param  table         the table to print
      * @param  printMode     the printing mode for this printable
      * @param  headerFormat  a <code>MessageFormat</code> specifying the text to
      *                       be used in printing a header, or null for none
      * @param  footerFormat  a <code>MessageFormat</code> specifying the text to
      *                       be used in printing a footer, or null for none
      * @throws IllegalArgumentException if passed an invalid print mode
      */
     public TablePrintable(JTable table,
                           JTable.PrintMode printMode,
                           MessageFormat headerFormat,
                           MessageFormat footerFormat) {

         this.table = table;

         header = table.getTableHeader();
         colModel = table.getColumnModel();
         totalColWidth = colModel.getTotalColumnWidth();

         if (header != null) {
             // the header clip height can be set once since it's unchanging
             hclip.height = header.getHeight();
         }

         this.printMode = printMode;

         this.headerFormat = headerFormat;
         this.footerFormat = footerFormat;

         // derive the header and footer font from the table's font
         headerFont = table.getFont().deriveFont(Font.BOLD,
                                                 HEADER_FONT_SIZE);
         footerFont = table.getFont().deriveFont(Font.PLAIN,
                                                 FOOTER_FONT_SIZE);
     }

     /**
      * Prints the specified page of the table into the given {@link Graphics}
      * context, in the specified format.
      *
      * @param   graphics    the context into which the page is drawn
      * @param   pageFormat  the size and orientation of the page being drawn
      * @param   pageIndex   the zero based index of the page to be drawn
      * @return  PAGE_EXISTS if the page is rendered successfully, or
      *          NO_SUCH_PAGE if a non-existent page index is specified
      * @throws  PrinterException if an error causes printing to be aborted
      */
     public int print(Graphics graphics, PageFormat pageFormat, int pageIndex)
                                                        throws PrinterException {

         // for easy access to these values
         final int imgWidth = (int)pageFormat.getImageableWidth();
         final int imgHeight = (int)pageFormat.getImageableHeight();

         if (imgWidth <= 0) {
             throw new PrinterException("Width of printable area is too small.");
         }

         // to pass the page number when formatting the header and footer text
         Object[] pageNumber = new Object[]{Integer.valueOf(pageIndex + 1)};

         // fetch the formatted header text, if any
         String headerText = null;
         if (headerFormat != null) {
             headerText = headerFormat.format(pageNumber);
         }

         // fetch the formatted footer text, if any
         String footerText = null;
         if (footerFormat != null) {
             footerText = footerFormat.format(pageNumber);
         }

         // to store the bounds of the header and footer text
         Rectangle2D hRect = null;
         Rectangle2D fRect = null;

         // the amount of vertical space needed for the header and footer text
         int headerTextSpace = 0;
         int footerTextSpace = 0;

         // the amount of vertical space available for printing the table
         int availableSpace = imgHeight;

         // if there's header text, find out how much space is needed for it
         // and subtract that from the available space
         if (headerText != null) {
             graphics.setFont(headerFont);
             hRect = graphics.getFontMetrics().getStringBounds(headerText,
                                                               graphics);

             headerTextSpace = (int)Math.ceil(hRect.getHeight());
             availableSpace -= headerTextSpace + H_F_SPACE;
         }

         // if there's footer text, find out how much space is needed for it
         // and subtract that from the available space
         if (footerText != null) {
             graphics.setFont(footerFont);
             fRect = graphics.getFontMetrics().getStringBounds(footerText,
                                                               graphics);

             footerTextSpace = (int)Math.ceil(fRect.getHeight());
             availableSpace -= footerTextSpace + H_F_SPACE;
         }

         if (availableSpace <= 0) {
             throw new PrinterException("Height of printable area is too small.");
         }

         // depending on the print mode, we may need a scale factor to
         // fit the table's entire width on the page
         double sf = 1.0D;
         if (printMode == JTable.PrintMode.FIT_WIDTH &&
                 totalColWidth > imgWidth) {

             // if not, we would have thrown an acception previously
             assert imgWidth > 0;

             // it must be, according to the if-condition, since imgWidth > 0
             assert totalColWidth > 1;

             sf = (double)imgWidth / (double)totalColWidth;
         }

         // dictated by the previous two assertions
         assert sf > 0;

         // This is in a loop for two reasons:
         // First, it allows us to catch up in case we're called starting
         // with a non-zero pageIndex. Second, we know that we can be called
         // for the same page multiple times. The condition of this while
         // loop acts as a check, ensuring that we don't attempt to do the
         // calculations again when we are called subsequent times for the
         // same page.
         while (last < pageIndex) {
             // if we are finished all columns in all rows
             if (row >= table.getRowCount() && col == 0) {
                 return NO_SUCH_PAGE;
             }

             // rather than multiplying every row and column by the scale factor
             // in findNextClip, just pass a width and height that have already
             // been divided by it
             int scaledWidth = (int)(imgWidth / sf);
             int scaledHeight = (int)((availableSpace - hclip.height) / sf);

             // calculate the area of the table to be printed for this page
             findNextClip(scaledWidth, scaledHeight);

             last++;
         }

         // create a copy of the graphics so we don't affect the one given to us
         Graphics2D g2d = (Graphics2D)graphics.create();

         // translate into the co-ordinate system of the pageFormat
         g2d.translate(pageFormat.getImageableX(), pageFormat.getImageableY());

         // to save and store the transform
         AffineTransform oldTrans;

         // if there's footer text, print it at the bottom of the imageable area
         if (footerText != null) {
             oldTrans = g2d.getTransform();

             g2d.translate(0, imgHeight - footerTextSpace);

             printText(g2d, footerText, fRect, footerFont, imgWidth);

             g2d.setTransform(oldTrans);
         }

         // if there's header text, print it at the top of the imageable area
         // and then translate downwards
         if (headerText != null) {
             printText(g2d, headerText, hRect, headerFont, imgWidth);

             g2d.translate(0, headerTextSpace + H_F_SPACE);
         }

         // constrain the table output to the available space
         tempRect.x = 0;
         tempRect.y = 0;
         tempRect.width = imgWidth;
         tempRect.height = availableSpace;
         g2d.clip(tempRect);

         // if we have a scale factor, scale the graphics object to fit
         // the entire width
         if (sf != 1.0D) {
             g2d.scale(sf, sf);

         // otherwise, ensure that the current portion of the table is
         // centered horizontally
         } else {
             int diff = (imgWidth - clip.width) / 2;
             g2d.translate(diff, 0);
         }

         // store the old transform and clip for later restoration
         oldTrans = g2d.getTransform();
         Shape oldClip = g2d.getClip();

         // if there's a table header, print the current section and
         // then translate downwards
         if (header != null) {
             hclip.x = clip.x;
             hclip.width = clip.width;

             g2d.translate(-hclip.x, 0);
             g2d.clip(hclip);
             header.print(g2d);

             // restore the original transform and clip
             g2d.setTransform(oldTrans);
             g2d.setClip(oldClip);

             // translate downwards
             g2d.translate(0, hclip.height);
         }

         // print the current section of the table
         g2d.translate(-clip.x, -clip.y);
         g2d.clip(clip);
         table.print(g2d);

         // restore the original transform and clip
         g2d.setTransform(oldTrans);
         g2d.setClip(oldClip);

         // draw a box around the table
         g2d.setColor(Color.BLACK);
         g2d.drawRect(0, 0, clip.width, hclip.height + clip.height);

         // dispose the graphics copy
         g2d.dispose();

         return PAGE_EXISTS;
     }

     /**
      * A helper method that encapsulates common code for rendering the
      * header and footer text.
      *
      * @param  g2d       the graphics to draw into
      * @param  text      the text to draw, non null
      * @param  rect      the bounding rectangle for this text,
      *                   as calculated at the given font, non null
      * @param  font      the font to draw the text in, non null
      * @param  imgWidth  the width of the area to draw into
      */
     private void printText(Graphics2D g2d,
                            String text,
                            Rectangle2D rect,
                            Font font,
                            int imgWidth) {

             int tx;

             // if the text is small enough to fit, center it
             if (rect.getWidth() < imgWidth) {
                 tx = (int)((imgWidth - rect.getWidth()) / 2);

             // otherwise, if the table is LTR, ensure the left side of
             // the text shows; the right can be clipped
             } else if (table.getComponentOrientation().isLeftToRight()) {
                 tx = 0;

             // otherwise, ensure the right side of the text shows
             } else {
                 tx = -(int)(Math.ceil(rect.getWidth()) - imgWidth);
             }

             int ty = (int)Math.ceil(Math.abs(rect.getY()));
             g2d.setColor(Color.BLACK);
             g2d.setFont(font);
             g2d.drawString(text, tx, ty);
     }

     /**
      * Calculate the area of the table to be printed for
      * the next page. This should only be called if there
      * are rows and columns left to print.
      *
      * To avoid an infinite loop in printing, this will
      * always put at least one cell on each page.
      *
      * @param  pw  the width of the area to print in
      * @param  ph  the height of the area to print in
      */
     private void findNextClip(int pw, int ph) {
         final boolean ltr = table.getComponentOrientation().isLeftToRight();

         // if we're ready to start a new set of rows
         if (col == 0) {
             if (ltr) {
                 // adjust clip to the left of the first column
                 clip.x = 0;
             } else {
                 // adjust clip to the right of the first column
                 clip.x = totalColWidth;
             }

             // adjust clip to the top of the next set of rows
             clip.y += clip.height;

             // adjust clip width and height to be zero
             clip.width = 0;
             clip.height = 0;

             // fit as many rows as possible, and at least one
             int rowCount = table.getRowCount();
             int rowHeight = table.getRowHeight(row);
             do {
                 clip.height += rowHeight;

                 if (++row >= rowCount) {
                     break;
                 }

                 rowHeight = table.getRowHeight(row);
             } while (clip.height + rowHeight <= ph);
         }

         // we can short-circuit for JTable.PrintMode.FIT_WIDTH since
         // we'll always fit all columns on the page
         if (printMode == JTable.PrintMode.FIT_WIDTH) {
             clip.x = 0;
             clip.width = totalColWidth;
             return;
         }

         if (ltr) {
             // adjust clip to the left of the next set of columns
             clip.x += clip.width;
         }

         // adjust clip width to be zero
         clip.width = 0;

         // fit as many columns as possible, and at least one
         int colCount = table.getColumnCount();
         int colWidth = colModel.getColumn(col).getWidth();
         do {
             clip.width += colWidth;
             if (!ltr) {
                 clip.x -= colWidth;
             }

             if (++col >= colCount) {
                 // reset col to 0 to indicate we're finished all columns
                 col = 0;

                 break;
             }

             colWidth = colModel.getColumn(col).getWidth();
         } while (clip.width + colWidth <= pw);

     }

 }
	/*
	* Copyright (c) 2003, 2008, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code 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 General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package javax.swing;

	import javax.swing.table.*;
	import java.awt.*;
	import java.awt.print.*;
	import java.awt.geom.*;
	import java.text.MessageFormat;

	/**
	* An implementation of <code>Printable</code> for printing
	* <code>JTable</code>s.
	* <p>
	* This implementation spreads table rows naturally in sequence
	* across multiple pages, fitting as many rows as possible per page.
	* The distribution of columns, on the other hand, is controlled by a
	* printing mode parameter passed to the constructor. When
	* <code>JTable.PrintMode.NORMAL</code> is used, the implementation
	* handles columns in a similar manner to how it handles rows, spreading them
	* across multiple pages (in an order consistent with the table's
	* <code>ComponentOrientation</code>).
	* When <code>JTable.PrintMode.FIT_WIDTH</code> is given, the implementation
	* scales the output smaller if necessary, to ensure that all columns fit on
	* the page. (Note that width and height are scaled equally, ensuring that the
	* aspect ratio remains the same).
	* <p>
	* The portion of table printed on each page is headed by the
	* appropriate section of the table's <code>JTableHeader</code>.
	* <p>
	* Header and footer text can be added to the output by providing
	* <code>MessageFormat</code> instances to the constructor. The
	* printing code requests Strings from the formats by calling
	* their <code>format</code> method with a single parameter:
	* an <code>Object</code> array containing a single element of type
	* <code>Integer</code>, representing the current page number.
	* <p>
	* There are certain circumstances where this <code>Printable</code>
	* cannot fit items appropriately, resulting in clipped output.
	* These are:
	* <ul>
	* <li>In any mode, when the header or footer text is too wide to
	* fit completely in the printable area. The implementation
	* prints as much of the text as possible starting from the beginning,
	* as determined by the table's <code>ComponentOrientation</code>.
	* <li>In any mode, when a row is too tall to fit in the
	* printable area. The upper most portion of the row
	* is printed and no lower border is shown.
	* <li>In <code>JTable.PrintMode.NORMAL</code> when a column
	* is too wide to fit in the printable area. The center of the
	* column is printed and no left and right borders are shown.
	* </ul>
	* <p>
	* It is entirely valid for a developer to wrap this <code>Printable</code>
	* inside another in order to create complex reports and documents. They may
	* even request that different pages be rendered into different sized
	* printable areas. The implementation was designed to handle this by
	* performing most of its calculations on the fly. However, providing different
	* sizes works best when <code>JTable.PrintMode.FIT_WIDTH</code> is used, or
	* when only the printable width is changed between pages. This is because when
	* it is printing a set of rows in <code>JTable.PrintMode.NORMAL</code> and the
	* implementation determines a need to distribute columns across pages,
	* it assumes that all of those rows will fit on each subsequent page needed
	* to fit the columns.
	* <p>
	* It is the responsibility of the developer to ensure that the table is not
	* modified in any way after this <code>Printable</code> is created (invalid
	* modifications include changes in: size, renderers, or underlying data).
	* The behavior of this <code>Printable</code> is undefined if the table is
	* changed at any time after creation.
	*
	* @author Shannon Hickey
	*/
	class TablePrintable implements Printable {

	/** The table to print. */
	private JTable table;

	/** For quick reference to the table's header. */
	private JTableHeader header;

	/** For quick reference to the table's column model. */
	private TableColumnModel colModel;

	/** To save multiple calculations of total column width. */
	private int totalColWidth;

	/** The printing mode of this printable. */
	private JTable.PrintMode printMode;

	/** Provides the header text for the table. */
	private MessageFormat headerFormat;

	/** Provides the footer text for the table. */
	private MessageFormat footerFormat;

	/** The most recent page index asked to print. */
	private int last = -1;

	/** The next row to print. */
	private int row = 0;

	/** The next column to print. */
	private int col = 0;

	/** Used to store an area of the table to be printed. */
	private final Rectangle clip = new Rectangle(0, 0, 0, 0);

	/** Used to store an area of the table's header to be printed. */
	private final Rectangle hclip = new Rectangle(0, 0, 0, 0);

	/** Saves the creation of multiple rectangles. */
	private final Rectangle tempRect = new Rectangle(0, 0, 0, 0);

	/** Vertical space to leave between table and header/footer text. */
	private static final int H_F_SPACE = 8;

	/** Font size for the header text. */
	private static final float HEADER_FONT_SIZE = 18.0f;

	/** Font size for the footer text. */
	private static final float FOOTER_FONT_SIZE = 12.0f;

	/** The font to use in rendering header text. */
	private Font headerFont;

	/** The font to use in rendering footer text. */
	private Font footerFont;

	/**
	* Create a new <code>TablePrintable</code> for the given
	* <code>JTable</code>. Header and footer text can be specified using the
	* two <code>MessageFormat</code> parameters. When called upon to provide
	* a String, each format is given the current page number.
	*
	* @param table the table to print
	* @param printMode the printing mode for this printable
	* @param headerFormat a <code>MessageFormat</code> specifying the text to
	* be used in printing a header, or null for none
	* @param footerFormat a <code>MessageFormat</code> specifying the text to
	* be used in printing a footer, or null for none
	* @throws IllegalArgumentException if passed an invalid print mode
	*/
	public TablePrintable(JTable table,
	JTable.PrintMode printMode,
	MessageFormat headerFormat,
	MessageFormat footerFormat) {

	this.table = table;

	header = table.getTableHeader();
	colModel = table.getColumnModel();
	totalColWidth = colModel.getTotalColumnWidth();

	if (header != null) {
	// the header clip height can be set once since it's unchanging
	hclip.height = header.getHeight();
	}

	this.printMode = printMode;

	this.headerFormat = headerFormat;
	this.footerFormat = footerFormat;

	// derive the header and footer font from the table's font
	headerFont = table.getFont().deriveFont(Font.BOLD,
	HEADER_FONT_SIZE);
	footerFont = table.getFont().deriveFont(Font.PLAIN,
	FOOTER_FONT_SIZE);
	}

	/**
	* Prints the specified page of the table into the given {@link Graphics}
	* context, in the specified format.
	*
	* @param graphics the context into which the page is drawn
	* @param pageFormat the size and orientation of the page being drawn
	* @param pageIndex the zero based index of the page to be drawn
	* @return PAGE_EXISTS if the page is rendered successfully, or
	* NO_SUCH_PAGE if a non-existent page index is specified
	* @throws PrinterException if an error causes printing to be aborted
	*/
	public int print(Graphics graphics, PageFormat pageFormat, int pageIndex)
	throws PrinterException {

	// for easy access to these values
	final int imgWidth = (int)pageFormat.getImageableWidth();
	final int imgHeight = (int)pageFormat.getImageableHeight();

	if (imgWidth <= 0) {
	throw new PrinterException("Width of printable area is too small.");
	}

	// to pass the page number when formatting the header and footer text
	Object[] pageNumber = new Object[]{Integer.valueOf(pageIndex + 1)};

	// fetch the formatted header text, if any
	String headerText = null;
	if (headerFormat != null) {
	headerText = headerFormat.format(pageNumber);
	}

	// fetch the formatted footer text, if any
	String footerText = null;
	if (footerFormat != null) {
	footerText = footerFormat.format(pageNumber);
	}

	// to store the bounds of the header and footer text
	Rectangle2D hRect = null;
	Rectangle2D fRect = null;

	// the amount of vertical space needed for the header and footer text
	int headerTextSpace = 0;
	int footerTextSpace = 0;

	// the amount of vertical space available for printing the table
	int availableSpace = imgHeight;

	// if there's header text, find out how much space is needed for it
	// and subtract that from the available space
	if (headerText != null) {
	graphics.setFont(headerFont);
	hRect = graphics.getFontMetrics().getStringBounds(headerText,
	graphics);

	headerTextSpace = (int)Math.ceil(hRect.getHeight());
	availableSpace -= headerTextSpace + H_F_SPACE;
	}

	// if there's footer text, find out how much space is needed for it
	// and subtract that from the available space
	if (footerText != null) {
	graphics.setFont(footerFont);
	fRect = graphics.getFontMetrics().getStringBounds(footerText,
	graphics);

	footerTextSpace = (int)Math.ceil(fRect.getHeight());
	availableSpace -= footerTextSpace + H_F_SPACE;
	}

	if (availableSpace <= 0) {
	throw new PrinterException("Height of printable area is too small.");
	}

	// depending on the print mode, we may need a scale factor to
	// fit the table's entire width on the page
	double sf = 1.0D;
	if (printMode == JTable.PrintMode.FIT_WIDTH &&
	totalColWidth > imgWidth) {

	// if not, we would have thrown an acception previously
	assert imgWidth > 0;

	// it must be, according to the if-condition, since imgWidth > 0
	assert totalColWidth > 1;

	sf = (double)imgWidth / (double)totalColWidth;
	}

	// dictated by the previous two assertions
	assert sf > 0;

	// This is in a loop for two reasons:
	// First, it allows us to catch up in case we're called starting
	// with a non-zero pageIndex. Second, we know that we can be called
	// for the same page multiple times. The condition of this while
	// loop acts as a check, ensuring that we don't attempt to do the
	// calculations again when we are called subsequent times for the
	// same page.
	while (last < pageIndex) {
	// if we are finished all columns in all rows
	if (row >= table.getRowCount() && col == 0) {
	return NO_SUCH_PAGE;
	}

	// rather than multiplying every row and column by the scale factor
	// in findNextClip, just pass a width and height that have already
	// been divided by it
	int scaledWidth = (int)(imgWidth / sf);
	int scaledHeight = (int)((availableSpace - hclip.height) / sf);

	// calculate the area of the table to be printed for this page
	findNextClip(scaledWidth, scaledHeight);

	last++;
	}

	// create a copy of the graphics so we don't affect the one given to us
	Graphics2D g2d = (Graphics2D)graphics.create();

	// translate into the co-ordinate system of the pageFormat
	g2d.translate(pageFormat.getImageableX(), pageFormat.getImageableY());

	// to save and store the transform
	AffineTransform oldTrans;

	// if there's footer text, print it at the bottom of the imageable area
	if (footerText != null) {
	oldTrans = g2d.getTransform();

	g2d.translate(0, imgHeight - footerTextSpace);

	printText(g2d, footerText, fRect, footerFont, imgWidth);

	g2d.setTransform(oldTrans);
	}

	// if there's header text, print it at the top of the imageable area
	// and then translate downwards
	if (headerText != null) {
	printText(g2d, headerText, hRect, headerFont, imgWidth);

	g2d.translate(0, headerTextSpace + H_F_SPACE);
	}

	// constrain the table output to the available space
	tempRect.x = 0;
	tempRect.y = 0;
	tempRect.width = imgWidth;
	tempRect.height = availableSpace;
	g2d.clip(tempRect);

	// if we have a scale factor, scale the graphics object to fit
	// the entire width
	if (sf != 1.0D) {
	g2d.scale(sf, sf);

	// otherwise, ensure that the current portion of the table is
	// centered horizontally
	} else {
	int diff = (imgWidth - clip.width) / 2;
	g2d.translate(diff, 0);
	}

	// store the old transform and clip for later restoration
	oldTrans = g2d.getTransform();
	Shape oldClip = g2d.getClip();

	// if there's a table header, print the current section and
	// then translate downwards
	if (header != null) {
	hclip.x = clip.x;
	hclip.width = clip.width;

	g2d.translate(-hclip.x, 0);
	g2d.clip(hclip);
	header.print(g2d);

	// restore the original transform and clip
	g2d.setTransform(oldTrans);
	g2d.setClip(oldClip);

	// translate downwards
	g2d.translate(0, hclip.height);
	}

	// print the current section of the table
	g2d.translate(-clip.x, -clip.y);
	g2d.clip(clip);
	table.print(g2d);

	// restore the original transform and clip
	g2d.setTransform(oldTrans);
	g2d.setClip(oldClip);

	// draw a box around the table
	g2d.setColor(Color.BLACK);
	g2d.drawRect(0, 0, clip.width, hclip.height + clip.height);

	// dispose the graphics copy
	g2d.dispose();

	return PAGE_EXISTS;
	}

	/**
	* A helper method that encapsulates common code for rendering the
	* header and footer text.
	*
	* @param g2d the graphics to draw into
	* @param text the text to draw, non null
	* @param rect the bounding rectangle for this text,
	* as calculated at the given font, non null
	* @param font the font to draw the text in, non null
	* @param imgWidth the width of the area to draw into
	*/
	private void printText(Graphics2D g2d,
	String text,
	Rectangle2D rect,
	Font font,
	int imgWidth) {

	int tx;

	// if the text is small enough to fit, center it
	if (rect.getWidth() < imgWidth) {
	tx = (int)((imgWidth - rect.getWidth()) / 2);

	// otherwise, if the table is LTR, ensure the left side of
	// the text shows; the right can be clipped
	} else if (table.getComponentOrientation().isLeftToRight()) {
	tx = 0;

	// otherwise, ensure the right side of the text shows
	} else {
	tx = -(int)(Math.ceil(rect.getWidth()) - imgWidth);
	}

	int ty = (int)Math.ceil(Math.abs(rect.getY()));
	g2d.setColor(Color.BLACK);
	g2d.setFont(font);
	g2d.drawString(text, tx, ty);
	}

	/**
	* Calculate the area of the table to be printed for
	* the next page. This should only be called if there
	* are rows and columns left to print.
	*
	* To avoid an infinite loop in printing, this will
	* always put at least one cell on each page.
	*
	* @param pw the width of the area to print in
	* @param ph the height of the area to print in
	*/
	private void findNextClip(int pw, int ph) {
	final boolean ltr = table.getComponentOrientation().isLeftToRight();

	// if we're ready to start a new set of rows
	if (col == 0) {
	if (ltr) {
	// adjust clip to the left of the first column
	clip.x = 0;
	} else {
	// adjust clip to the right of the first column
	clip.x = totalColWidth;
	}

	// adjust clip to the top of the next set of rows
	clip.y += clip.height;

	// adjust clip width and height to be zero
	clip.width = 0;
	clip.height = 0;

	// fit as many rows as possible, and at least one
	int rowCount = table.getRowCount();
	int rowHeight = table.getRowHeight(row);
	do {
	clip.height += rowHeight;

	if (++row >= rowCount) {
	break;
	}

	rowHeight = table.getRowHeight(row);
	} while (clip.height + rowHeight <= ph);
	}

	// we can short-circuit for JTable.PrintMode.FIT_WIDTH since
	// we'll always fit all columns on the page
	if (printMode == JTable.PrintMode.FIT_WIDTH) {
	clip.x = 0;
	clip.width = totalColWidth;
	return;
	}

	if (ltr) {
	// adjust clip to the left of the next set of columns
	clip.x += clip.width;
	}

	// adjust clip width to be zero
	clip.width = 0;

	// fit as many columns as possible, and at least one
	int colCount = table.getColumnCount();
	int colWidth = colModel.getColumn(col).getWidth();
	do {
	clip.width += colWidth;
	if (!ltr) {
	clip.x -= colWidth;
	}

	if (++col >= colCount) {
	// reset col to 0 to indicate we're finished all columns
	col = 0;

	break;
	}

	colWidth = colModel.getColumn(col).getWidth();
	} while (clip.width + colWidth <= pw);

	}

	}