13.4 Printing Multipage Text Documents

The printing examples we've seen so far print GUI components on a single page. Printing multipage documents is more interesting, but also trickier, because we have to decide where to place the page breaks. Example 13-4 shows how this can be done. This HardcopyWriter class is a custom java.io.Writer stream that uses the Java 1.1 Printing API to print the characters sent through it, inserting line breaks and page breaks as necessary.

The HardcopyWriter class includes two demonstration programs as inner classes. The first, PrintFile, reads a specified text file and prints it by sending its contents to a HardcopyWriter stream. The second, Demo, prints a demonstration page that shows off the font and tabbing capabilities of the class, as shown in Figure 13-4.

Figure 13-4. Demonstration page printed by HardcopyWriter

Example 13-4 is long but worth studying. In addition to demonstrating the Java 1.1 Printing API again, it shows an approach to paginating a text document. It is also a useful example of a custom Writer stream.

Example 13-4. HardcopyWriter.java

package je3.print; import java.awt.*; import java.awt.event.*; import java.io.*; import java.text.*; import java.util.*; /**   * A character output stream that sends output to a printer.  **/ public class HardcopyWriter extends Writer {     // These are the instance variables for the class     protected PrintJob job;                 // The PrintJob object in use     protected Graphics page;                // Graphics object for current page     protected String jobname;               // The name of the print job     protected int fontsize;                 // Point size of the font     protected String time;                  // Current time (appears in header)     protected Dimension pagesize;           // Size of the page (in dots)     protected int pagedpi;                  // Page resolution in dots per inch     protected Font font, headerfont;        // Body font and header font     protected FontMetrics metrics;          // Metrics for the body font     protected FontMetrics headermetrics;    // Metrics for the header font     protected int x0, y0;                   // Upper-left corner inside margin     protected int width, height;            // Size (in dots) inside margins     protected int headery;                  // Baseline of the page header     protected int charwidth;                // The width of each character     protected int lineheight;               // The height of each line     protected int lineascent;               // Offset of font baseline     protected int chars_per_line;           // Number of characters per line     protected int lines_per_page;           // Number of lines per page     protected int charnum = 0, linenum = 0; // Current column and line position     protected int pagenum = 0;              // Current page number     // A field to save state between invocations of the write( ) method     private boolean last_char_was_return = false;     // A static variable that holds user preferences between print jobs     protected static Properties printprops = new Properties( );     /**      * The constructor for this class has a bunch of arguments:        * The frame argument is required for all printing in Java.      * The jobname appears left justified at the top of each printed page.      * The font size is specified in points, as on-screen font sizes are.      * The margins are specified in inches (or fractions of inches).      **/     public HardcopyWriter(Frame frame, String jobname, int fontsize,                            double leftmargin, double rightmargin,                           double topmargin, double bottommargin)          throws HardcopyWriter.PrintCanceledException     {         // Get the PrintJob object with which we'll do all the printing.         // The call is synchronized on the static printprops object, which          // means that only one print dialog can be popped up at a time.         // If the user clicks Cancel in the print dialog, throw an exception.         Toolkit toolkit = frame.getToolkit( );   // get Toolkit from Frame         synchronized(printprops) {             job = toolkit.getPrintJob(frame, jobname, printprops);         }         if (job == null)              throw new PrintCanceledException("User cancelled print request");                  pagesize = job.getPageDimension( );      // query the page size         pagedpi = job.getPageResolution( );      // query the page resolution                  // Bug Workaround:         // On Windows, getPageDimension( ) and getPageResolution don't work, so         // we've got to fake them.         if (System.getProperty("os.name").regionMatches(true,0,"windows",0,7)){             // Use screen dpi, which is what the PrintJob tries to emulate             pagedpi = toolkit.getScreenResolution( );             // Assume a 8.5" x 11" page size.  A4 paper users must change this.             pagesize = new Dimension((int)(8.5 * pagedpi), 11*pagedpi);             // We also have to adjust the fontsize.  It is specified in points,             // (1 point = 1/72 of an inch) but Windows measures it in pixels.             fontsize = fontsize * pagedpi / 72;         }                  // Compute coordinates of the upper-left corner of the page.         // I.e. the coordinates of (leftmargin, topmargin).  Also compute         // the width and height inside of the margins.         x0 = (int)(leftmargin * pagedpi);         y0 = (int)(topmargin * pagedpi);         width = pagesize.width - (int)((leftmargin + rightmargin) * pagedpi);         height = pagesize.height - (int)((topmargin + bottommargin) * pagedpi);                  // Get body font and font size         font = new Font("Monospaced", Font.PLAIN, fontsize);           metrics = frame.getFontMetrics(font);         lineheight = metrics.getHeight( );         lineascent = metrics.getAscent( );         charwidth = metrics.charWidth('0');  // Assumes a monospaced font!                  // Now compute the number of columns and lines          // that will fit inside the margins         chars_per_line = width / charwidth;         lines_per_page = height / lineheight;                  // Get header font information         // And compute baseline of page header: 1/8" above the top margin         headerfont = new Font("SansSerif", Font.ITALIC, fontsize);         headermetrics = frame.getFontMetrics(headerfont);         headery = y0 - (int)(0.125 * pagedpi) -               headermetrics.getHeight( ) + headermetrics.getAscent( );                  // Compute the date/time string to display in the page header         DateFormat df = DateFormat.getDateTimeInstance(DateFormat.LONG,                                                        DateFormat.SHORT);         df.setTimeZone(TimeZone.getDefault( ));         time = df.format(new Date( ));                  this.jobname = jobname;                 // save name         this.fontsize = fontsize;               // save font size     }          /**      * This is the write( ) method of the stream.  All Writer subclasses       * implement this.  All other versions of write( ) are variants of this one      **/     public void write(char[  ] buffer, int index, int len) {         synchronized(this.lock) {  // For thread safety             // Loop through all the characters passed to us             for(int i = index; i < index + len; i++) {                 // If we haven't begun a page (or a new page), do that now.                 if (page == null) newpage( );                                  // If the character is a line terminator, then begin new line,                  // unless it is a \n immediately after a \r.                 if (buffer[i] == '\n') {                     if (!last_char_was_return) newline( );                     continue;                 }                 if (buffer[i] == '\r') {                     newline( );                     last_char_was_return = true;                     continue;                 }                 else last_char_was_return = false;                                  // If it's some other non-printing character, ignore it.                 if (Character.isWhitespace(buffer[i]) &&                     !Character.isSpaceChar(buffer[i]) && (buffer[i] != '\t'))                     continue;                                  // If no more characters will fit on the line, start new line.                 if (charnum >= chars_per_line) {                     newline( );                     // Also start a new page, if necessary                     if (page == null) newpage( );                   }                                  // Now print the character:                 // If it is a space, skip one space, without output.                 // If it is a tab, skip the necessary number of spaces.                 // Otherwise, print the character.                 // It is inefficient to draw only one character at a time, but                 // because our FontMetrics don't match up exactly to what the                 // printer uses, we need to position each character individually                 if (Character.isSpaceChar(buffer[i])) charnum++;                 else if (buffer[i] == '\t') charnum += 8 - (charnum % 8);                 else {                     page.drawChars(buffer, i, 1,                                     x0 + charnum * charwidth,                                     y0 + (linenum*lineheight) + lineascent);                     charnum++;                 }             }         }     }          /**       * This is the flush( ) method that all Writer subclasses must implement.      * There is no way to flush a PrintJob without prematurely printing the      * page, so we don't do anything.      **/     public void flush( ) { /* do nothing */ }          /**      * This is the close( ) method that all Writer subclasses must implement.      * Print the pending page (if any) and terminate the PrintJob.      */     public void close( ) {         synchronized(this.lock) {             if (page != null) page.dispose( );   // Send page to the printer             job.end( );                          // Terminate the job         }     }          /**      * Set the font style.  The argument should be one of the font style       * constants defined by the java.awt.Font class.  All subsequent output      * will be in that style.  This method relies on all styles of the      * Monospaced font having the same metrics.      **/     public void setFontStyle(int style) {         synchronized (this.lock) {             // Try to set a new font, but restore current one if it fails             Font current = font;             try { font = new Font("Monospaced", style, fontsize); }             catch (Exception e) { font = current; }             // If a page is pending, set the new font. Otherwise newpage( ) will             if (page != null) page.setFont(font);         }     }          /** End the current page.  Subsequent output will be on a new page. */     public void pageBreak( ) { synchronized(this.lock) { newpage( ); } }          /** Return the number of columns of characters that fit on the page */     public int getCharactersPerLine( ) { return this.chars_per_line; }          /** Return the number of lines that fit on a page */     public int getLinesPerPage( ) { return this.lines_per_page; }          /** This internal method begins a new line */     protected void newline( ) {         charnum = 0;                      // Reset character number to 0         linenum++;                        // Increment line number         if (linenum >= lines_per_page) {  // If we've reached the end of page             page.dispose( );                 //  send page to printer             page = null;                    //  but don't start a new page yet.         }     }          /** This internal method begins a new page and prints the header. */     protected void newpage( ) {         page = job.getGraphics( );              // Begin the new page         linenum = 0; charnum = 0;              // Reset line and char number         pagenum++;                             // Increment page number         page.setFont(headerfont);              // Set the header font.         page.drawString(jobname, x0, headery); // Print job name left justified                  String s = "- " + pagenum + " -";      // Print the page # centered.         int w = headermetrics.stringWidth(s);         page.drawString(s, x0 + (this.width - w)/2, headery);         w = headermetrics.stringWidth(time);   // Print date right justified         page.drawString(time, x0 + width - w, headery);                  // Draw a line beneath the header         int y = headery + headermetrics.getDescent( ) + 1;         page.drawLine(x0, y, x0+width, y);                  // Set the basic monospaced font for the rest of the page.         page.setFont(font);     }          /**      * This is the exception class that the HardcopyWriter constructor      * throws when the user clicks "Cancel" in the print dialog box.      **/     public static class PrintCanceledException extends Exception {         public PrintCanceledException(String msg) { super(msg); }     }          /**      * A program that prints the specified file using HardcopyWriter      **/     public static class PrintFile {         public static void main(String[  ] args) {             try {                 if (args.length != 1)                      throw new IllegalArgumentException("Wrong # of arguments");                 FileReader in = new FileReader(args[0]);                 HardcopyWriter out = null;                 Frame f = new Frame("PrintFile: " + args[0]);                 f.setSize(200, 50);                 f.show( );                 try {                     out = new HardcopyWriter(f, args[0], 10, .5, .5, .5, .5);                 }                  catch (HardcopyWriter.PrintCanceledException e) {                     System.exit(0);                 }                 f.setVisible(false);                 char[  ] buffer = new char[4096];                 int numchars;                 while((numchars = in.read(buffer)) != -1)                      out.write(buffer, 0, numchars);                 in.close( );                 out.close( );             }             catch (Exception e) {                 System.err.println(e);                 System.err.println("Usage: " +                                    "java HardcopyWriter$PrintFile <filename>");                 System.exit(1);             }             System.exit(0);          }     }          /**       * A program that prints a demo page using HardcopyWriter      **/     public static class Demo extends Frame implements ActionListener {         /** The main method of the program.  Create a test window */         public static void main(String[  ] args) {             Frame f = new Demo( );             f.show( );         }         // Buttons used in this program         protected Button print, quit;                  /** Constructor for the test program's window. */         public Demo( ) {             super("HardcopyWriter Test");          // Call frame constructor             Panel p = new Panel( );                 // Add a panel to the frame             this.add(p, "Center");                 // Center it             p.setFont(new Font("SansSerif",        // Set a default font                                Font.BOLD, 18));             print = new Button("Print Test Page"); // Create a Print button             quit = new Button("Quit");             // Create a Quit button             print.addActionListener(this);         // Specify that we'll handle             quit.addActionListener(this);          //   button presses             p.add(print);                          // Add the buttons to panel             p.add(quit);             this.pack( );                           // Set the frame size         }                  /** Handle the button presses */         public void actionPerformed(ActionEvent e) {             Object o = e.getSource( );             if (o == quit) System.exit(0);             else if (o == print) printDemoPage( );         }                  /** Print the demo page */         public void printDemoPage( ) {             // Create a HardcopyWriter, using a 10 point font and 3/4" margins.             HardcopyWriter hw;             try { hw=new HardcopyWriter(this, "Demo Page",10,.75,.75,.75,.75);}             catch (HardcopyWriter.PrintCanceledException e) { return; }                          // Send output to it through a PrintWriter stream             PrintWriter out = new PrintWriter(hw);                          // Figure out the size of the page             int rows = hw.getLinesPerPage( ), cols = hw.getCharactersPerLine( );                          // Mark upper-left and upper-right corners             out.print("+");                            // upper-left corner             for(int i=0;i<cols-2;i++) out.print(" ");  // space over             out.print("+");                            // upper-right corner                          // Display a title             hw.setFontStyle(Font.BOLD + Font.ITALIC);             out.println("\n\t\tHardcopy Writer Demo Page\n\n");                          // Demonstrate font styles             hw.setFontStyle(Font.BOLD);             out.println("Font Styles:");             int[  ] styles = { Font.PLAIN, Font.BOLD,                              Font.ITALIC, Font.ITALIC+Font.BOLD };             for(int i = 0; i < styles.length; i++) {                 hw.setFontStyle(styles[i]);                 out.println("ABCDEFGHIJKLMNOPQRSTUVWXYZ" +                              "abcdefghijklmnopqrstuvwxyz");                 out.println("1234567890!@#$%^&*( )[  ]{  }<>,.?:;+-=/\\`'\"_~|");             }             hw.setFontStyle(Font.PLAIN);             out.println("\n");                          // Demonstrate tab stops             hw.setFontStyle(Font.BOLD);             out.println("Tab Stops:");             hw.setFontStyle(Font.PLAIN);             out.println("          1         2         3         4         5");             out.println("012345678901234567890123456789012345678901234567890");             out.println("^\t^\t^\t^\t^\t^\t^");             out.println("\n");                          // Output some information about page dimensions and resolution             hw.setFontStyle(Font.BOLD);             out.println("Dimensions:");             hw.setFontStyle(Font.PLAIN);             out.println("\tResolution: " + hw.pagedpi + " dots per inch");             out.println("\tPage width (pixels): " + hw.pagesize.width);             out.println("\tPage height (pixels): " + hw.pagesize.height);             out.println("\tWidth inside margins (pixels): " + hw.width);             out.println("\tHeight inside margins (pixels): " + hw.height);             out.println("\tCharacters per line: " + cols);             out.println("\tLines per page: " + rows);                          // Skip down to the bottom of the page             for(int i = 0; i < rows-30; i++) out.println( );             // And mark the lower-left and lower-right             out.print("+");                            // lower-left             for(int i=0;i<cols-2;i++) out.print(" ");  // space-over             out.print("+");                            // lower-right                          // Close the output stream, forcing the page to be printed             out.close( );         }     } }