In this chapter:

• Java 2 Printing API overview
• Printing images
• Print preview
• Printing styled text
• Printing tables

With Java 2 comes a considerably advanced printing API. Java veterans may recall that JDK 1.0 didn't provide printing capabilities at all. JDK 1.1 provided access to native print jobs, but multi-page printing was a real problem for that API.

This is the main class which controls printing in Java 2. It is used to store print job properties, to initiate printing when necessary, and to control the display of Print dialogs. A typical printing process is shown in the following code:

    PrinterJob prnJob = PrinterJob.getPrinterJob();
    prnJob.setPrintable(myPrintable);
    if (!prnJob.printDialog())
      return;
    prnJob.print();

The Print dialog will look familiar, as it is the typical dialog used by most other applications on the user’s system. For example, figure 22.1 shows a Windows NT Print dialog:

<<file figure22-1.gif>>

Though this explains some of the performance problems that we will see in the coming examples, it seems that the model described above is not exactly what we are dealing with in Java 2 FCS. In fact, after some investigation§ , it turns out that the division into bands is not based on available memory. Rather, a hard-coded 512k buffer is used. By increasing the size of this buffer, it is feasible to increase performance significantly. However, this would involve modification of peer-level classes; something that we are certainly not encouraged to do. We hope to see this limitation accounted for in future releases.

This class encapsulates a Paper object and adds to it an orientation property (landscape or portrait). We can force a Printable to use a specific PageFormat by passing one to PrinterJob’s overloaded setPrintable() method. For instance, the following would force a printable job to use a specific PageFormat with a landscape orientation:

    PrinterJob prnJob = PrinterJob.getPrinterJob();

    PageFormat pf = job.defaultPage();

    pf.setOrientation(PageFormat.LANDSCAPE);

    prnJob.setPrintable(myPrintable, pf);
    if (!prnJob.printDialog())
      return;
    prnJob.print();

PageFormat defines three orientations:

We can optionally display a page setup dialog in which the user can specify page characteristics such as orientation, paper size, margin size, etc. This dialog will return a new PageFormat to use in printing. The page setup dialog is meant to be presented before the Print dialog and can be displayed using PrinterJob’s pageDialog() method. The following code brings up a page setup dialog, and uses the resulting PageFormat for printing a printable job:

    PrinterJob prnJob = PrinterJob.getPrinterJob();

    PageFormat pf = job.pageDialog(job.defaultPage());

    prnJob.setPrintable(myPrintable, pf);

    if (!prnJob.printDialog())
      return;

    prnJob.print();

Note that we need to pass the pageDialog() method a PageFormat instance, as it uses it to clone and modify as the user specifies. If the changes are accepted the cloned and modifed version is returned. If they are not, the original version passed in is returned. Figure 22.2 shows a Windows NT page setup dialog:

This class holds the size and margins of the paper used for printing. Methods getImageableX() and getImageableY() retrieve the coordinates of the top-left corner of the printable area in 1/72nds of an inch (which is approximately equal to one screen pixel--referred to as a "point" in typography). Methods getImageableWidth() and getImageableHeight() retrieve the width and height of the printable area (also in 1/72nds of an inch). We can also change the size of the useable region of the paper using its setImageableArea() method.

We can access the Paper object associated with a PageFormat using PageFormat’s getPaper() and setPaper() methods.

This class represents a collection of Printable instances with corresponding PageFormats to represent a complex document whose pages may have different formats. The Book class implements the Pageable interface, and Printables are added to a Book using one of its append() methods. This class also defines several methods allowing for the manipulation and replacement of specific pages. (A page in terms of a Book is a Printable-PageFormat pair. Each page does correspond to an actual printed page.) See the API docs and the Java Tutorial for more information about this class.

This exception may be thrown to indicate an error during a printing procedure. It has two concrete sub-classes: PrinterAbortException and PrinterIOException. The former indicates that a print job was terminated by the application or user while printing, and the latter indicates that there was a problem outputting to the printer.

In this section we add printing capabilities to the JPEGEditor application introduced in chapter 13. This example will form a solid basis for the subsequent printing examples. Here we show how to implement the Printable interface to construct a custom panel with a print() method that can manage the printing of large images by splitting them up into a matrix of pages.

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.util.*;
import java.io.*;

import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import javax.swing.filechooser.*;

import com.sun.image.codec.jpeg.*;

import java.awt.print.*;

// Unchanged code from section 13.4

public class JPEGEditor extends JFrame 
{
  // Unchanged code from section 13.4

  protected JMenuBar createMenuBar() {
    // Unchanged code from section 13.4

    mItem = new JMenuItem("Print...");
    mItem.setMnemonic('p');
    ActionListener lstPrint = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        Thread runner = new Thread() {
          public void run() { 
            if (m_panel.getBufferedImage() != null)
              printData();
          }
        };
        runner.start();
      }
    };
    mItem.addActionListener(lstPrint);
    mFile.add(mItem);
    mFile.addSeparator();

    mItem = new JMenuItem("Exit");
    mItem.setMnemonic('x');
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        System.exit(0);
      }
    };
    mItem.addActionListener(lst);
    mFile.add(mItem);
    menuBar.add(mFile);
    return menuBar;
  }

  // Unchanged code from section 13.4

  public void printData() {
    getJMenuBar().repaint();
    try {
      PrinterJob prnJob = PrinterJob.getPrinterJob();
      prnJob.setPrintable(m_panel);
      if (!prnJob.printDialog())
        return;
      setCursor( Cursor.getPredefinedCursor(
        Cursor.WAIT_CURSOR));
      prnJob.print();
      setCursor( Cursor.getPredefinedCursor(
        Cursor.DEFAULT_CURSOR));
      JOptionPane.showMessageDialog(this, 
        "Printing completed successfully", "JPEGEditor2",
        JOptionPane.INFORMATION_MESSAGE);
    }
    catch (PrinterException e) {
      e.printStackTrace();
      System.err.println("Printing error: "+e.toString());
    }
  }

  public static void main(String argv[]) {
    new JPEGEditor();
  }
}

class JPEGPanel extends JPanel implements Printable
{
  protected BufferedImage m_bi = null;

  public int m_maxNumPage = 1;

  // Unchanged code from section 13.4

  public int print(Graphics pg, PageFormat pageFormat,
   int pageIndex) throws PrinterException {
    if (pageIndex >= m_maxNumPage || m_bi == null)
      return NO_SUCH_PAGE;

    pg.translate((int)pageFormat.getImageableX(), 
      (int)pageFormat.getImageableY());
    int wPage = (int)pageFormat.getImageableWidth();
    int hPage = (int)pageFormat.getImageableHeight();

    int w = m_bi.getWidth(this);
    int h = m_bi.getHeight(this);
    if (w == 0 || h == 0)
      return NO_SUCH_PAGE;
    int nCol = Math.max((int)Math.ceil((double)w/wPage), 1);
      int nRow = Math.max((int)Math.ceil((double)h/hPage), 1);
    m_maxNumPage = nCol*nRow;

    int iCol = pageIndex % nCol;
    int iRow = pageIndex / nCol;
    int x = iCol*wPage;
    int y = iRow*hPage;
    int wImage = Math.min(wPage, w-x);
    int hImage = Math.min(hPage, h-y);

    pg.drawImage(m_bi, 0, 0, wImage, hImage, 
      x, y, x+wImage, y+hImage, this);
    System.gc();
        
    return PAGE_EXISTS;
  }
}

The java.awt.print package is imported to provide printing capabilities. A new menu item titled "Print..." has been added to the "File" menu of this application. If this item is selected and an image has been loaded, our new custom printData()method is called.

The printData() method retrieves a PrinterJob instance and passes it our m_panel component (an instance of JPEGPanel -- which now implements the Printable interface, see below). It then invokes a native Print dialog and initializes printing by calling print(). If no exception was thrown, a "Printing completed successfully" message is displayed when printing completes. Otherwise the exception trace is printed.

This class, which was originally designed to just display an image, now implements the Printable interface and is able to print a portion of its displayed image upon request. A new instance variable, m_maxNumPage, holds a maximum page number available for this printing. This number is set initially to one and its actual value is calculated in the print() method (see below).

The print() method prints a portion of the current image corresponding to the given page index. If the current image is larger than a single page, it will be split into several pages which are arranged as several rows and columns (a matrix). When printed they can be placed in this arrangement to form one big printout.

First this method shifts the origin of the graphics context to take into account the page's margins, and calculates the width and height of the area available for drawing: wPage and hPage.

Local variables w and h represent the width and height of the whole BufferedImage to be printed. (If any of these happens to be 0 we return NO_SUCH_PAGE.) Comparing these dimensions with the width and height of a single page, we can calculate the number of columns (not less than 1) and rows (not less than 1) in which the original image should be split to fit to the page's size:

The product of rows and columns gives us the number of pages in the print job, m_maxNumPage.

Now, because we know the index of the current page to be printed (it was passed as parameter pageIndex) we can determine the current column and row indices (note that enumeration is made from left to right and then from top to bottom), iCol and iRow:

We also can calculate the coordinates of the top-left corner of the portion of the image to be printed on this page (x and y), and the width and height of this region (wImage and hImage). Note that in the last column or row of our image matrix, the width and/or height of a portion can be less then the maximum values (which we calculated above--wPage and hPage).

Now we have everything ready to actually print a region of the image to the specified graphics context. We now need to extract this region and draw it at (0, 0), as this will be the origin (upper-left hand corner) of our printed page. The Graphics drawImage() method does the job. It takes ten parameters: an Image instance, four coordinates of the destination area (top-left and bottom-right--not width and height), four coordinates of the source area, and an ImageObserver instance.

The most annoying thing with Java 2 printing is that is terribly slow. This is mainly because we are dealing with an Image (BufferedImage is a subclass of Image). Images and printing clash severely. As we will see in later examples, printing is much faster when Images are not involved.

public class JPEGEditor extends JFrame 
{
  // Unchanged code from section 22.2

  protected JMenuBar createMenuBar() {

    // Unchanged code from section 22.2

    mItem = new JMenuItem("Print Preview");
    mItem.setMnemonic('v');
    ActionListener lstPreview = new ActionListener() { 
      public void actionPerformed(ActionEvent e) { 
        Thread runner = new Thread() {
          public void run() {
            setCursor(Cursor.getPredefinedCursor(
              Cursor.WAIT_CURSOR));
            if (m_panel.getBufferedImage() != null)
              new PrintPreview(m_panel, 
               m_currentFile.getName()+" preview");
            setCursor(Cursor.getPredefinedCursor(
            Cursor.DEFAULT_CURSOR));
          }
        };
        runner.start();
      }
    };
    mItem.addActionListener(lstPreview);
    mFile.add(mItem);

    mFile.addSeparator();

import java.awt.*;
import java.awt.event.*;
import java.awt.image.*;
import java.util.*;
import java.awt.print.*;

import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;

public class PrintPreview extends JFrame 
{
  protected int m_wPage;
  protected int m_hPage;
  protected Printable m_target;
  protected JComboBox m_cbScale;
  protected PreviewContainer m_preview;

  public PrintPreview(Printable target) {
    this(target, "Print Preview");
  }

  public PrintPreview(Printable target, String title) {
    super(title);
    setSize(600, 400);
    m_target = target;

    JToolBar tb = new JToolBar();
    JButton bt = new JButton("Print", new ImageIcon("print.gif"));
    ActionListener lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) { 
        try {
          // Use default printer, no dialog
          PrinterJob prnJob = PrinterJob.getPrinterJob();
          prnJob.setPrintable(m_target);
          setCursor( Cursor.getPredefinedCursor(
            Cursor.WAIT_CURSOR));
          prnJob.print();
          setCursor( Cursor.getPredefinedCursor(
            Cursor.DEFAULT_CURSOR));
          dispose();
        }
        catch (PrinterException ex) {
          ex.printStackTrace();
          System.err.println("Printing error: "+ex.toString());
        }
      }
    };
    bt.addActionListener(lst);
    bt.setAlignmentY(0.5f);
    bt.setMargin(new Insets(4,6,4,6));
    tb.add(bt);

    bt = new JButton("Close");
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) { 
        dispose();
      }
    };
    bt.addActionListener(lst);
    bt.setAlignmentY(0.5f);
    bt.setMargin(new Insets(2,6,2,6));
    tb.add(bt);

    String[] scales = { "10 %", "25 %", "50 %", "100 %" };
    m_cbScale = new JComboBox(scales);
    lst = new ActionListener() { 
      public void actionPerformed(ActionEvent e) { 
        Thread runner = new Thread() {
          public void run() {
            String str = m_cbScale.getSelectedItem().
              toString();
            if (str.endsWith("%"))
              str = str.substring(0, str.length()-1);
            str = str.trim();
              int scale = 0;
            try { scale = Integer.parseInt(str); }
            catch (NumberFormatException ex) { return; }
            int w = (int)(m_wPage*scale/100);
            int h = (int)(m_hPage*scale/100);

            Component[] comps = m_preview.getComponents();
            for (int k=0; k<comps.length; k++) {
              if (!(comps[k] instanceof PagePreview))
                continue;
              PagePreview pp = (PagePreview)comps[k];
                pp.setScaledSize(w, h);
            }
            m_preview.doLayout();
            m_preview.getParent().getParent().validate();
          }
        };
        runner.start();
      }
    };
    m_cbScale.addActionListener(lst);
    m_cbScale.setMaximumSize(m_cbScale.getPreferredSize());
    m_cbScale.setEditable(true);
    tb.addSeparator();
    tb.add(m_cbScale);
    getContentPane().add(tb, BorderLayout.NORTH);

    m_preview = new PreviewContainer();

    PrinterJob prnJob = PrinterJob.getPrinterJob();
    PageFormat pageFormat = prnJob.defaultPage();
    if (pageFormat.getHeight()==0 || pageFormat.getWidth()==0) {
      System.err.println("Unable to determine default page size");
        return;
    }
    m_wPage = (int)(pageFormat.getWidth());
    m_hPage = (int)(pageFormat.getHeight());
    int scale = 10;
    int w = (int)(m_wPage*scale/100);
    int h = (int)(m_hPage*scale/100);

    int pageIndex = 0;
    try {
      while (true) {
        BufferedImage img = new BufferedImage(m_wPage, 
          m_hPage, BufferedImage.TYPE_INT_RGB);
        Graphics g = img.getGraphics();
        g.setColor(Color.white);
        g.fillRect(0, 0, m_wPage, m_hPage);
        if (target.print(g, pageFormat, pageIndex) != 
         Printable.PAGE_EXISTS)
          break;
        PagePreview pp = new PagePreview(w, h, img);
        m_preview.add(pp);
        pageIndex++;
      }
    }
    catch (PrinterException e) {
      e.printStackTrace();
      System.err.println("Printing error: "+e.toString());
    }

    JScrollPane ps = new JScrollPane(m_preview);
    getContentPane().add(ps, BorderLayout.CENTER);

    setDefaultCloseOperation(DISPOSE_ON_CLOSE);
    setVisible(true);
  }

  class PreviewContainer extends JPanel
  {
    protected int H_GAP = 16;
    protected int V_GAP = 10;

    public Dimension getPreferredSize() {
      int n = getComponentCount();
      if (n == 0)
        return new Dimension(H_GAP, V_GAP);
      Component comp = getComponent(0);
      Dimension dc = comp.getPreferredSize();
      int w = dc.width;
      int h = dc.height;
           
      Dimension dp = getParent().getSize();
      int nCol = Math.max((dp.width-H_GAP)/(w+H_GAP), 1);
      int nRow = n/nCol;
      if (nRow*nCol < n)
        nRow++;

      int ww = nCol*(w+H_GAP) + H_GAP;
      int hh = nRow*(h+V_GAP) + V_GAP;
      Insets ins = getInsets();
      return new Dimension(ww+ins.left+ins.right, 
        hh+ins.top+ins.bottom);
    }

    public Dimension getMaximumSize() {
      return getPreferredSize();
    }

    public Dimension getMinimumSize() {
      return getPreferredSize();
    }

    public void doLayout() {
      Insets ins = getInsets();
      int x = ins.left + H_GAP;
      int y = ins.top + V_GAP;

      int n = getComponentCount();
      if (n == 0)
        return;
      Component comp = getComponent(0);
      Dimension dc = comp.getPreferredSize();
      int w = dc.width;
      int h = dc.height;
            
      Dimension dp = getParent().getSize();
      int nCol = Math.max((dp.width-H_GAP)/(w+H_GAP), 1);
      int nRow = n/nCol;
      if (nRow*nCol < n)
        nRow++;

      int index = 0;
      for (int k = 0; k<nRow; k++) {
        for (int m = 0; m<nCol; m++) {
          if (index >= n)
            return;
          comp = getComponent(index++);
          comp.setBounds(x, y, w, h);
          x += w+H_GAP;
        }
        y += h+V_GAP;
        x = ins.left + H_GAP;
      }
    }
  }

  class PagePreview extends JPanel
  {
    protected int m_w;
    protected int m_h;
    protected Image m_source;
    protected Image m_img;

    public PagePreview(int w, int h, Image source) {
      m_w = w;
      m_h = h;
      m_source= source;
      m_img = m_source.getScaledInstance(m_w, m_h, 
        Image.SCALE_SMOOTH);
      m_img.flush();
      setBackground(Color.white);
      setBorder(new MatteBorder(1, 1, 2, 2, Color.black));
    }

    public void setScaledSize(int w, int h) {
      m_w = w;
      m_h = h;
      m_img = m_source.getScaledInstance(m_w, m_h, 
        Image.SCALE_SMOOTH);
      repaint();
    }

    public Dimension getPreferredSize() {
      Insets ins = getInsets();
      return new Dimension(m_w+ins.left+ins.right, 
        m_h+ins.top+ins.bottom);
    }

    public Dimension getMaximumSize() {
      return getPreferredSize();
    }

    public Dimension getMinimumSize() {
      return getPreferredSize();
    }

    public void paint(Graphics g) {
      g.setColor(getBackground());
      g.fillRect(0, 0, getWidth(), getHeight());
      g.drawImage(m_img, 0, 0, this);
      paintBorder(g);
    }
  }
}

Compared to the previous example this class has only one difference: it creates a menu item titled "Print Preview." When selected, this item creates an instance of the PrintPreview class (see below). This class’s constructor takes two parameters: a reference to a Printable instance and a text string for the frame's title. As we have seen in the previous example, our m_panel component implements the Printable interface and provides the actual printing functionality, so we use it to create the PrintPreview instance. Note that this call is wrapped in a thr! ead because, when used with large images, creation of a PrintPreview instance can take a significant amount of time.

This class represents a JFrame-based component which is capable of displaying the results of printing before actual printing occurs. Several instance variables are used:

Two public constructors are provided. The first one takes an instance of the Printable interface and passes control to the second constructor, using the Printable along with the "Print Preview" String as parameters. The second constructor takes two parameters: an instance of the Printable interface and the title string for the frame. This second constructor is the one that actually sets up the PrintPreview component.

First, a toolbar is created and a button titled "Print" is added to perform printing of the m_target instance as described in the previous example. The only difference is that no Print dialog is invoked, and the default system printer is used (this approach is typical for print preview components). When the printing is complete, this print preview component is disposed. The second button added to the toolbar is labeled "Close" and merely disposes of this frame component.

The third (and the last) component added to the toolbar is the editable combobox m_cbScale, which selects a percent scale to zoom the previewed pages. Along with several pre-defined choices (10 %, 25 %, 50 %, and 100 %) any percent value can be entered. As soon as that value is selected and the corresponding ActionListener involved, the zoom scale value is extracted and stored in the local variable scale. This determines the width and height of each PreviewPage component we will be creating:

Then all child components of the m_preview container in turn are cast to PagePreview components (each child is expected to be a PagePreview instance, but instanceof is used for precaution), and the setScaledSize() method is invoked to assign a new size to the preview pages. Finally doLayout() is invoked on m_preview to lay out the resized child components, and validate() is invoked on the scroll pane. This scroll pane is the parent of the m_preview component in the second generation (the first parent is a JViewport component--see chapter 7). This last call is necessary to display/hide scroll bars as needed for the new size of the m_preview container. This whole process is wrapped in a thread to avoid clogging up the AWT event-dispatching thread.

When toolbar construction is complete, the m_preview component is created and filled with the previewed pages. To do so we first retrieve a PrinterJob instance for a default system printer without displaying a Page Setup dialog, and retrieve a default PageFormat instance. We use this to determine the initial size of the previewed pages by multiplying its dimensions by the computed scaling percentile (which is 10% at initialization time, because scale is set to 10).

To create these scalable preview pages we set up a while loop to continuously call the print() method of the given Printable instance, using a page index that gets incremented each iteration, until it returns something other than Printable.PAGE_EXISTS.

Each page is rendered into a separate image in memory. To do this, an instance of BufferedImage is created with width m_wPage and height m_hPage. A Graphics instance is retrieved from that image using getGraphics():

  BufferedImage img = new BufferedImage(m_wPage, m_hPage, BufferedImage.TYPE_INT_RGB);
  Graphics g = img.getGraphics();
  g.setColor(Color.white);
  g.fillRect(0, 0, m_wPage, m_hPage);
  if (target.print(g, pageFormat, pageIndex) != Printable.PAGE_EXISTS)
    break;

After filling the image's area with a white background (most paper is white), this Graphics instance, along with the PageFormat and current page index, pageIndex, are passed to the print() method of the Printable object.

If the call to the print() method returns PAGE_EXISTS, indicating success in the rendering of the new page, a new PagePreview component is created:

Note that our newly created BufferedImage is passed to the PagePreview constructor as one of the parameters. This is so that we can use it now and in the future for scaling each PagePreview component separately. The other parameters are the width and height to use, which, at creation time, are 10% of the page size (as discussed above).

Each new component is added to our m_preview container. Finally, when the Printable’s print() method finishes, our m_preview container is placed in a JScrollPane to provide scrolling capabilities. This scroll pane is then added to the center of the PrintPreview frame, and our frame is then made visible.

This inner class extends JPanel to serve as a container for PagePreview components. The only reason this custom container is developed is because we have specific layout requirements. What we want here is a layout which places its child components from left to right, without any resizing (using their preferred size), and leaves equal gaps between them. When the available container's width is filled, a new row should be started from the left edge, without regard to the available height (we assume scrolling functionality will be made available).

This inner class extends JPanel to serve as a placeholder for the image of each printed page preview. Four instance variables are used:

The constructor of the PagePreview class takes its initial width, height, and the source image. It creates a scaled image by calling the getScaledInstance() method and sets its border to MatteBorder(1, 1, 2, 2, Color.black) to imitate a page laying on a flat surface.

The setScaledSize() method may be called to resize this component. It takes a new width and height as parameters and creates a new scaled image corresponding to the new size. Usage of the SCALE_SMOOTH option for scaling is essential to get a preview image which looks like a zoomed printed page (although it is not the fastest option).

The paint() method draws a scaled image and draws a border around the component.

In this section we’ll add printing capabilities to the RTF word processor application developed in chapter 20. The printing of styled text would be easy if JTextComponent or JTextPane implemented the Printable interface and provided the capability to print their content. Unfortunately this is not the case (at least as of Java 2 FCS). So we have to get fairly clever, and create our own BoxView subclass to specifically handle printing.

Our styled editor class will now implement the Printable interface and delegate the mechanics of printing of each page to our custom BoxView subclass. Note that this custom view is not actually displayed on the screen as the editor. It sits in the background and is used only for printing and display in our print preview component.

Recall, from our discussion in chapters 11 and 19, that styled documents consist of a hierarchy of elements: paragraphs, images, components, etc. Each element is rendered by an associated view, which are all children of the root view. A BoxView in particular, arranges all its child views along either the x or y axis (typically the y axis). So, in this example, when we need to render a page, we start from the first child view of our custom BoxView, and render each of the child views sequentially, placing each below the previous in the vertical direction. When the next page should be rendered, we start from the first remaining view and continue in this fashion until all child views have been rendered. (This process will be explained in greater detail below.)

import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.util.*;
import java.sql.*;

import java.awt.print.*;
import javax.swing.plaf.basic.*;

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import javax.swing.border.*;
import javax.swing.text.rtf.*;
import javax.swing.undo.*;

import dl.*;

public class WordProcessor extends JFrame implements Printable
{
  // Unchanged code from section 20.9

  protected PrintView m_printView;

  // Unchanged code from section 20.9

  protected JMenuBar createMenuBar() {

    // Unchanged code from section 20.9

    mFile.addSeparator();

    Action actionPrint = new AbstractAction("Print...", 
     new ImageIcon("print.gif")) { 
      public void actionPerformed(ActionEvent e) {
        Thread runner = new Thread() {
          public void run() {
            printData();
          }
        };
        runner.start();
      }
    };
    item =  mFile.add(actionPrint);  
    item.setMnemonic('p');

    item = new JMenuItem("Print Preview");
    item.setMnemonic('v');
    ActionListener lstPreview = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        Thread runner = new Thread() {
          public void run() {
            setCursor(Cursor.getPredefinedCursor(
              Cursor.WAIT_CURSOR));
            new PrintPreview(WordProcessor.this);
            setCursor(Cursor.getPredefinedCursor(
              Cursor.DEFAULT_CURSOR));
          }
        };
        runner.start();
      }
    };
    item.addActionListener(lstPreview);
    mFile.add(item);

    mFile.addSeparator();

    // Unchanged code from section 20.9
  }

  // Unchanged code from section 20.9

  public void printData() {
    getJMenuBar().repaint();
    try {
      PrinterJob prnJob = PrinterJob.getPrinterJob();
      prnJob.setPrintable(this);
      if (!prnJob.printDialog())
        return;
      setCursor( Cursor.getPredefinedCursor(
        Cursor.WAIT_CURSOR));
      prnJob.print();
      setCursor( Cursor.getPredefinedCursor(
        Cursor.DEFAULT_CURSOR));
      JOptionPane.showMessageDialog(this, 
        "Printing completed successfully", "Info",
        JOptionPane.INFORMATION_MESSAGE);
    }
    catch (PrinterException e) {
      e.printStackTrace();
      System.err.println("Printing error: "+e.toString());
    }
  }

  public int print(Graphics pg, PageFormat pageFormat,
   int pageIndex) throws PrinterException {
    pg.translate((int)pageFormat.getImageableX(), 
      (int)pageFormat.getImageableY());
    int wPage = (int)pageFormat.getImageableWidth();
    int hPage = (int)pageFormat.getImageableHeight();
    pg.setClip(0, 0, wPage, hPage);

    // Only do this once per print
    if (m_printView == null) {
      BasicTextUI btui = (BasicTextUI)m_monitor.getUI();
      View root = btui.getRootView(m_monitor);
      m_printView = new PrintView(
        m_doc.getDefaultRootElement(), 
        root, wPage, hPage);
    }
        
    boolean bContinue = m_printView.paintPage(pg, 
      hPage, pageIndex);
    System.gc();
        
    if (bContinue)
      return PAGE_EXISTS;
    else {
      m_printView = null;
      return NO_SUCH_PAGE;
    }
  }

  public static void main(String argv[]) {
    new WordProcessor();
  }

  // Unchanged code from section 20.9

  class PrintView extends BoxView
  {
    protected int m_firstOnPage = 0;
    protected int m_lastOnPage = 0;
    protected int m_pageIndex = 0;

    public PrintView(Element elem, View root, int w, int h) {
      super(elem, Y_AXIS);
      setParent(root);
      setSize(w, h);
      layout(w, h);
    }

    public boolean paintPage(Graphics g, int hPage, 
     int pageIndex) {
      if (pageIndex > m_pageIndex) {
        m_firstOnPage = m_lastOnPage + 1;
        if (m_firstOnPage >= getViewCount())
          return false;
        m_pageIndex = pageIndex;
      }
      int yMin = getOffset(Y_AXIS, m_firstOnPage);
      int yMax = yMin + hPage;
      Rectangle rc = new Rectangle();

      for (int k = m_firstOnPage; k < getViewCount(); k++) {
        rc.x = getOffset(X_AXIS, k);
        rc.y = getOffset(Y_AXIS, k);
        rc.width = getSpan(X_AXIS, k);
        rc.height = getSpan(Y_AXIS, k);
        if (rc.y+rc.height > yMax)
          break;
        m_lastOnPage = k;
        rc.y -= yMin;
        paintChild(g, rc, k);
      }
      return true;
    }
  }

In comparison to the example of section 20.9, this class imports two new packages: java.awt.print and javax.swing.plaf.basic. The first one provides the necessary printing API, while the second is used to gain access to text component UI delegates (we will soon see why this is necessary).

One new instance variable, PrintView m_printView, represents our custom view used to print the styled document (see below). The createMenuBar() method now creates and adds to the "File" menu two new menu items titled "Print..." and "Print Preview". When the first one is selected it calls the printData() method, while the second one creates a PrintPreview instance by passing WordProcessor.this as the Printable reference. The printData() method obtains a PrinterJob instance, invokes a native Print dialog, and initializes printing the same way as we've seen in previous examples.

The print() method is called to print a given page of the current styled document. First, this method determines the size and origin of the printable area using a PageFormat instance as we've seen before. Next we need to set a clip area of the graphics context to the size of this printable area. This is necessary for the rendering of text component Views because they do clipping area intersection detection for optimized painting. If we don’t set the clipping area, they won’t know how to render themselves.

Unfortunately, the Printable interface does not provide any methods which can be called to initialize specific resources before printing, and release these resources after printing. So we must implement this functionality ourselves. The actual job of rendering the styled document is done by the m_printView object, which must be instantiated before printing begins, and released when it ends. Being forced to do all this in a single method, we first check if the m_printView reference is null. If it is then we assign it a new instance of PrintVew. If it isn’t null we don’t modify it (this indicates that we are in the midst of a printing session). When printing ends, we then set it to null so that the remaining PrintView instance can be garbage collected.

    // Only do this once per print 
    if (m_printView == null) {
      BasicTextUI btui = (BasicTextUI)m_monitor.getUI();
      View root = btui.getRootView(m_monitor);
      m_printView = new PrintView(m_doc.getDefaultRootElement(), 
                                  root, wPage, maxHeight);
    }

To create an m_printView object we need to access the BasicTextUI instance for our m_monitor JTextPane component, and retrieve its root View (which sits on the top of the hierarchy of views--see chapter 19) using BasicTextUI’s getRootView() method. At this point the PrintView instance can be created. Its constructor takes four parameters: the root element of the curre! nt document, the root view, and the width and height of the entire document’s printing bounds.

As soon as we're sure that the m_printView object exists, we call its custom paintPage() method to render a page with the given index to the given graphical context. Then the garbage collector is called explicitly in an attempt to cut down on the heavy memory usage.

Finally if the paintPage() call returns true, the PAGE_EXISTS value is returned to indicate a successful render. Otherwise we set the m_printView reference to null, and return NO_SUCH_PAGE to indicate that no more pages can be rendered.

This inner class extends BoxView and is used to render the content of a styled document. (Note that since this class extends BoxView, we have access to some of its protected methods, such as getOffset(), getSpan(), layout(), and paintChild().)

The PrintView constructor creates the underlying BoxView object for a given root Element instance (this should be the root element in the document model of the text component we are printing) and the specified axis used for format/break operations (this is normally Y_AXIS). A given View instance is then set as the parent for this PrintView (this should be the root View of the text component we are printing). The setSize() method is called to set the size of this view, and layout() is called to lay out the child views based on the specified width and height (this is done to calculate the coordinates of all views used in the rendering of this document). These operations may be time consuming for large documents. Fortunately they are only performed at construction time:

   public PrintView(Element elem, View root, int w, int h) {
      super(elem, Y_AXIS);
      setParent(root);
      setSize(w, h);
      layout(w, h);
   }

Our paintPage() method renders a single page of a styled document. It takes three parameters:

This method will return true if the page with the given index is rendered successfully, or false if the end of the document is reached. We assume that the pages to be rendered will be fetched in sequential order (although more than one call can be made to print the most recently rendered page). If a new page index is greater than m_pageIndex (which holds the index of the last rendered page), we begin rendering from the next view after the last one rendered on the previous page, and set m_firstOnPage to m_lastOnPage + 1. If this exceeds the number of child views, no more rendering can be done, so we retu! rn false.

      m_firstOnPage = m_lastOnPage + 1;

      if (m_firstOnPage >= getViewCount())
        return false;

Local variables yMin and yMax denote top and bottom coordinates of the page being rendered relative to the top of the document. yMin is determined by the offset of the first view to be rendered, and yMax is then yMin plus the height of the page:

All child views, from m_firstOnPage to the last view that will fit on the current page, are examined sequentially in a loop. In each iteration, local variable, Rectangle rc, is assigned the coordinates of where the associated child view is placed in the document (not on the current page). Based on the height of this view, if there is enough room horizontally to render it (note that it is guaranteed to fit vertically, since the page’s width was specified in the layout() call above), the paintChild() method is called to render it into the graphics context. Also note that we offset the y-coordinate of the view by yMin because, as we just mentioned, each child view is positioned in terms of the whole document, and we are only concerned with its position on the current page. If at any point a view will not fit within the remaining page space we exit the loop.

      for (int k = m_firstOnPage; k < getViewCount(); k++) {
        rc.x = getOffset(X_AXIS, k);
        rc.y = getOffset(Y_AXIS, k);
        rc.width = getSpan(X_AXIS, k);
        rc.height = getSpan(Y_AXIS, k);
        if (rc.y+rc.height > yMax)
          break;
        m_lastOnPage = k;
          rc.y -= yMin;
        paintChild(g, rc, k);
      }
      return true;

In this section we'll add printing capabilities to the JTable application developed earlier in chapter 18. Unlike other examples in this chapter, a printed table should not resemble the JTable component as displayed on the screen. This requires us to add detailed code for the rendering of the table's contents as it should be displayed in a printout. The resulting code, however, does not depend on the table's structure and can be easily used for printing any table component. Thus, the code presented here can be plugged into any JTable application that needs printing functionality. Combined with our print preview component (see previous examples), the amount of work we need to do to support printing of tab! les in professional applicatons is minimal.

import java.awt.*;
import java.awt.event.*;
import java.util.*;
import java.io.*;
import java.text.*;
import java.sql.*;
import java.awt.print.*;

import javax.swing.*;
import javax.swing.border.*;
import javax.swing.event.*;
import javax.swing.table.*;

public class StocksTable extends JFrame implements Printable
{
  protected JTable m_table;
  protected StockTableData m_data;
  protected JLabel m_title;

  protected int m_maxNumPage = 1;

  // Unchanged code from section 18.6

  protected JMenuBar createMenuBar() {
    // Unchanged code from section 18.6

    JMenuItem mPrint = new JMenuItem("Print...");
    mPrint.setMnemonic('p');
    ActionListener lstPrint = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        Thread runner = new Thread() {
          public void run() {
            printData();
          }
        };
        runner.start(); 
      }
    };
    mPrint.addActionListener(lstPrint);
    mFile.add(mPrint);

    JMenuItem mPreview = new JMenuItem("Print Preview");
    mPreview.setMnemonic('v');
    ActionListener lstPreview = new ActionListener() { 
      public void actionPerformed(ActionEvent e) {
        Thread runner = new Thread() {
          public void run() {
            setCursor(Cursor.getPredefinedCursor(
              Cursor.WAIT_CURSOR));
            new PrintPreview(Table7.this, 
            m_title.getText()+" preview");
            setCursor(Cursor.getPredefinedCursor(
              Cursor.DEFAULT_CURSOR));
          }
        };
        runner.start();
      }
    };
    mPreview.addActionListener(lstPreview);
    mFile.add(mPreview);
    mFile.addSeparator();

    // Unchanged code from section 18.6
  }

  public void printData() {
    try {
      PrinterJob prnJob = PrinterJob.getPrinterJob();
      prnJob.setPrintable(this);
      if (!prnJob.printDialog())
        return;
      m_maxNumPage = 1;
      prnJob.print();
    }
    catch (PrinterException e) {
      e.printStackTrace();
      System.err.println("Printing error: "+e.toString());
    }
  }
    
  public int print(Graphics pg, PageFormat pageFormat,
   int pageIndex) throws PrinterException {
    if (pageIndex >= m_maxNumPage)
      return NO_SUCH_PAGE;

    pg.translate((int)pageFormat.getImageableX(), 
      (int)pageFormat.getImageableY());
    int wPage = 0;
    int hPage = 0;
    if (pageFormat.getOrientation() == pageFormat.PORTRAIT) {
      wPage = (int)pageFormat.getImageableWidth();
      hPage = (int)pageFormat.getImageableHeight();
    }
    else {
      wPage = (int)pageFormat.getImageableWidth();
      wPage += wPage/2;
      hPage = (int)pageFormat.getImageableHeight();
      pg.setClip(0,0,wPage,hPage);
    }

    int y = 0;
    pg.setFont(m_title.getFont());
    pg.setColor(Color.black);
    Font fn = pg.getFont();
    FontMetrics fm = pg.getFontMetrics();
    y += fm.getAscent();
    pg.drawString(m_title.getText(), 0, y);
    y += 20; // space between title and table headers

    Font headerFont = m_table.getFont().deriveFont(Font.BOLD);
    pg.setFont(headerFont);
    fm = pg.getFontMetrics();

    TableColumnModel colModel = m_table.getColumnModel();
    int nColumns = colModel.getColumnCount();
    int x[] = new int[nColumns];
    x[0] = 0;
        
    int h = fm.getAscent();
    y += h; // add ascent of header font because of baseline
            // positioning (see figure 2.10)
 
    int nRow, nCol;
    for (nCol=0; nCol<nColumns; nCol++) {
      TableColumn tk = colModel.getColumn(nCol);
      int width = tk.getWidth();
      if (x[nCol] + width > wPage) {
        nColumns = nCol;
        break;
      }
      if (nCol+1<nColumns)
        x[nCol+1] = x[nCol] + width;
      String title = (String)tk.getIdentifier();
      pg.drawString(title, x[nCol], y);
    }

    pg.setFont(m_table.getFont());
    fm = pg.getFontMetrics();
        
    int header = y;
    h = fm.getHeight();
    int rowH = Math.max((int)(h*1.5), 10);
    int rowPerPage = (hPage-header)/rowH;
    m_maxNumPage = Math.max((int)Math.ceil(m_table.getRowCount()/
      (double)rowPerPage), 1);

    TableModel tblModel = m_table.getModel();
    int iniRow = pageIndex*rowPerPage;
    int endRow = Math.min(m_table.getRowCount(), 
      iniRow+rowPerPage);
        
    for (nRow=iniRow; nRow<endRow; nRow++) {
      y += h;
      for (nCol=0; nCol<nColumns; nCol++) {
        int col = m_table.getColumnModel().getColumn(nCol).getModelIndex();
        Object obj = m_data.getValueAt(nRow, col);
        String str = obj.toString();
        if (obj instanceof ColorData)
          pg.setColor(((ColorData)obj).m_color);
        else
          pg.setColor(Color.black);
          pg.drawString(str, x[nCol], y);
      }
    }

    System.gc();
    return PAGE_EXISTS;
  }

In comparison with the table examples of chapter 18, we now implement the Printable interface. In our createMenuBar() method we add a "Print..." menu item, which calls our new printData() method which acts just like the printData() methods we implemented in the examples above.

In our implementation of the print() method, we first determine whether a valid page index has been specified by comparing it to the maximum number of pages, m_maxNumPage:

The catch is that we don't know this maximum number in advance. So we assign an initial value of 1 to m_maxNumPage (the code above works for the 0-th page), and adjust m_maxNumPage to the real value later in the code, just as we’ve done in the examples above.

We then translate the origin of the graphics context to the origin of the given PageFormat instance and determine the width and height of the area available for printing. These dimensions are used to determine how much data can fit on the given page. This same technique was also used in the previous examples. However, in this example we’ve added the ability to print with a landscape orientation because tables can be quite wide, and we normally don’t want table data to span multiple pages (at least horizontally). In order to do this we have to first check the orientation of the given PageFormat instance. If it is PORTRAIT we determine its width and height as we have always done. If it is not PORTRAIT, then it must be either LANDSCAPE or REVERSE_LANDSCAPE (see section 22.1.5). In this case we need to increase the width of the page because the default is not adequate. After increasing the width we must also explicitly set the size of the graphics clip,

Local variable y is created to keep track of the current vertical position on the page, and we are now ready to actually start the rendering, and begin with the the table's title. Note that we use the same font as is used in the table application for consistency. We add some white space below the title (by increasing y) and then we make preparations for printing our table's headers and body. A bold font is used for our table's header. An array, x[], is created which will be used to store the x coordinate of each column’s upper left corner (taking into account that they may be resized and moved). Variable nColumns contains the total number of columns in our table.

Now we actually iterate through the columns and print each column header while filling our x[] array. We check each iteration to see if the x coordinate of the previous column, combined with the width of the column under consideration, will be more than the width of the page. If so we set the total number of columns, nColumns, to the number that will actually fit on the page, and then break out of the loop. If not we set the x coordinate corresponding to the current column, print its title, and continue on to the next iteration.

Since we've completed the printing of our table's title and headers, we know how much space is left for printing our table's body. We also know the font's height, so we can calculate how many rows can be printed on one page, which is rowPerPage below (the height of the page minus the current y offset, all divided by the height of the current font or 10, whichever is larger). Finally we calculate the real number of pages, m_maxNumPage, by dividing the total row count of our table by the number of rows per page we just calculated as rowPerPage. The minimum page count will be 1.

Now we need to actually print the table data. First we calculate the initial iniRow and final endRow rows to be printed on this page:

Then, in a double for loop, iterating through each column of each row in turn, we print the table’s contents. This is done by extracting each cell’s data as an Object (using getValueAt()). We store its toString() String representation in a local variable and check if the object is an instance of our custom inner class, ColorData (defined in earlier chapter 18 examples). This class is designed to associate a color with a given data object. So if the object is a ColorData instance we grab its color and assign it as the current color of the graphics context. If it isn’t we use black. Finally, we print that object’s toString() representation and continue on to the remaining cells.

We end by explicitly invoking the garbage collector and returning PAGE_EXISTS to indicate a successful print.

At this point you can compile and execute this example. Figure 22.4 shows a print preview of our table application. Try manipulating the table's contents (by choosing different dates if you have JDBC and ODBC -- see chapter 18) and column orders to see how it affects the table's printout and print preview.

You will notice that in order to fit the whole table on the paper it must be condensed considerably. It is natural at this point to want to print it with a landscape orientation. When we choose landscape from the Page Setup dialog this modifies the PageFormat object that will be sent to our print() method when printing begins. However, this will not actually tell the printer to print in landscape mode. In order to do this, we have to explicitly choose landscape mode from the Print dialog as well. Unfortunately, the Page Setup information does not inform the printer, but it is necessary to inform our application.

Though our application can print successfully with a landscape orientation, our print preview component is not designed to display anything but portrait-oriented previews. Because of the way our PrintPreview component has been constructed, it is quite easy to add the ability to preview landscape-oriented pages if desired. The only modification that is necessary, is the addition of a parameter to its constructor which specifyies the orientation to use. This parameter can then be assigned to the PageFormat object used in constructing each PagePreview object. We will not show the code here, but we have included a modified version of PrintPreview and the StocksTable application to demonstrate how you can implement this functionality. See \Chapter22\5. Figure 22.7 illustrates.