Printing JTable with DefaultTableCellRenderer (or JLabel's)

Question

Hi there,
I am trying to print a JTable by having it implement the Printable interface. It works, but it works only because I use the string values from the renderers of the cells. This works fine if its just simple left alligned strings.
But when you are using formatted text strings for instance (in a DefaultTableCellRenderer extension) or something that represents a boolean (a checkbox), it doesn't look very good. Bad actually. I tried to use the print method on the renderer or cast them first to a JComponent or JLabel and then use the print method. No success so far. Can anybody help me? I am quit desperate right now.
Kind regards,
Ren�

Answer 1

Yes I can. I took the print method from the class in which I implemented it (the JTable is a member of that particular class):
* Implementing the Printable interface.
* For printing the same font is used as is used on the screen.
* So, no special print font is used or can be choosen at this
* point. Also the font size is taken from the table on screen.
* The title font is twice the font size of the normal font, but
* bold. The column headers have the same font as the normal font
* but also bold like the title.
* The height we'll be using for a line of text will be 1.5 times
* the average height in this font, with a minimum of 10.
* The title font, the table header font and the table content font
* are all the same (unlike the table) and based on the table font.
* The table header font is not used.
* If the table does not fit on paper, one could adjust the orientation
* of the paper in the paper dialog, or adjust the distance bewtween
* the columns on the screen as the column width on the screen is
* taken to the paper.
public int print(Graphics pg, PageFormat pageFormat, int pageIndex) throws PrinterException {
if (pageIndex >= m_maxNumPage) {
return NO_SUCH_PAGE;
// This is for anti aliasing.
Graphics2D g2d = null;
if (pg instanceof Graphics2D) {
g2d = (Graphics2D) pg;
g2d.addRenderingHints(new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON));
g2d.addRenderingHints(new RenderingHints(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON));
pg.translate((int) pageFormat.getImageableX(), (int) pageFormat.getImageableY());
int wPage = (int) pageFormat.getImageableWidth();
int hPage = (int) pageFormat.getImageableHeight();
// This will make sure no printing is
// done outside the designated area.
pg.setClip(0, 0, wPage, hPage);
// Forget this: its a test (works fine though).
//table.print(g2d);
//if (true)
// return PAGE_EXISTS;
int y = 0;
// Make the title font size twice the size of the regular font size.
pg.setFont(this.table.getFont().deriveFont(Font.BOLD, (this.table.getFont().getSize() * 2)));
pg.setColor(Color.black);
FontMetrics fm = pg.getFontMetrics();
y += fm.getAscent();
// Draw the title, the date and the page number.
pg.drawString(pageTitle + " " + DateFormat.getDateInstance(DateFormat.MEDIUM, this.locale).format(new Date(System.currentTimeMillis())) + " (" + (pageIndex + 1) + ") ", 0, y);
//          pg.drawString(pageTitle + " " + DateFormat.getDateInstance().format(new Date(System.currentTimeMillis())) + " (" + (pageIndex + 1) + ") ", 0, y);
y += 20; // space between title and table headers
// The font for the table headers.
Font headerFont = this.table.getTableHeader().getFont();
pg.setFont(headerFont);
fm = pg.getFontMetrics();
TableColumnModel colModel = this.table.getColumnModel();
int nColumns = colModel.getColumnCount();
int x[] = new int[nColumns];
x[0] = 0;
int h = fm.getAscent();
// Add ascent of header font because of baseline positioning.
y += h;
int nRow, nCol;
// Draw the COLUMN HEADERS.
for (nCol = 0; nCol < nColumns; nCol++) {
TableColumn tk = colModel.getColumn(nCol);
int width = tk.getWidth();
String title = (String) tk.getIdentifier();
// The x offset for each column stored.
if (nCol + 1 < nColumns) {
x[nCol + 1] = x[nCol] + width;
// If this is not the last column header, calculated
// how many characters can be printed, based on the
// width of the column being printed.
if ((nCol < (nColumns - 1)) && title.length() > 0) {
//if (x[nCol] + width <= wPage) {
for (int i = title.length(); i >= 0; i--) {
if ((fm.stringWidth(title.substring(0, i))) <= width) {
// Adjust the colum header for the space available (the width).
title = title.substring(0, i);
break;
// Draw the column header.
pg.drawString(title, x[nCol], y);
pg.setFont(this.table.getFont());
fm = pg.getFontMetrics();
int header = y;
// Gets the standard height of a line of text in this font.
// This is the distance between the baseline of adjacent lines of text.
// It is the sum of the leading + ascent + descent. There is no guarantee
// that lines of text spaced at this distance are disjoint; such lines may
// overlap if some characters overshoot either the standard ascent or the
// standard descent metric.
h = fm.getHeight();
// Calculate the ACTUAL height we'll be using for a line of text.
// That would be 1.5 times the average height, with a minimum of 10.
// Actually, normally, the average height should suffice. But we're
// not taking any risks here.
int rowHeight = Math.max((int) (h * 1.5), 10);
// Calculate how many rows fit on a page.
int rowPerPage = (hPage - header) / rowHeight;
m_maxNumPage = Math.max((int) Math.ceil(this.table.getRowCount() / (double) rowPerPage), 1);
int iniRow = pageIndex * rowPerPage;
int endRow = Math.min(this.table.getRowCount(), iniRow + rowPerPage);
String cell = null;
// Draw every ROW.
for (nRow = iniRow; nRow < endRow; nRow++) {
y += rowHeight;
// Draw each CELL in each ROW.
for (nCol = 0; nCol < nColumns; nCol++) {
cell = null;
int col = this.table.getColumnModel().getColumn(nCol).getModelIndex();
// Get the cell object. This is the object that needs to be printed.
Object object = model.getValueAt(nRow, col);
// RENDERING FOR PRINTING! Here is determined for the printing how the rendering is done.
// If a special renderer had been set an attempt is made to use that renderer (e.g. get the text).
// If that is not possible, simple rendering: the toString() value.
// BE AWARE! The format for numbers, booleans etc. might require better code.
if (table.getColumnModel().getColumn(nCol).getCellRenderer() != null) {
if (table.getColumnModel().getColumn(nCol).getCellRenderer().getTableCellRendererComponent(table, object, false, false, nRow, nCol) != null) {
if (table.getColumnModel().getColumn(nCol).getCellRenderer().getTableCellRendererComponent(table, object, false, false, nRow, nCol) instanceof JLabel) {
cell = ((JLabel) table.getColumnModel().getColumn(nCol).getCellRenderer().getTableCellRendererComponent(table, object, false, false, nRow, nCol)).getText();
//table.getCellRenderer(0, nCol).getTableCellRendererComponent(table, object, false, false, 0, nCol).paint(g2d);
// Object fiets = table.getCellRenderer(0, nCol).getTableCellRendererComponent(table, object, false, false, 0, nCol);
// if (fiets instanceof DefaultTableCellRenderer) {
//      System.out.println("DefaultTableCellRenderer!" + nCol);
//      ((DefaultTableCellRenderer) fiets).print(pg);
// If the object is a Boolean, print an "X" or an "O".
if (object instanceof Boolean) {
cell = (((Boolean) object).equals(new Boolean(true)) ? "X" : "O");
// Still don't know how to print it? Use the object's toString() method.
// This is probably used in most cases anyway!
if (cell == null && object != null) {
//cell = object.toString();
if (cell == null) {
cell = "";
// If this is not the last column, calculated how many
// characters can be printed, based on the width of
// the column being printed.
if ((nCol < (nColumns - 1)) && cell.length() > 0) {
int width = colModel.getColumn(nCol).getWidth();
for (int i = cell.length(); i >= 0; i--) {
if ((fm.stringWidth(cell.substring(0, i))) <= width) {
// Adjust the size.
cell = cell.substring(0, i);
break;
// Print the cell.
pg.drawString(cell, x[nCol], y);
System.gc();
return PAGE_EXISTS;
}