/* * Copyright (c) 2000 David Flanagan.  All rights reserved. * This code is from the book Java Examples in a Nutshell, 2nd Edition. * It is provided AS-IS, WITHOUT ANY WARRANTY either expressed or implied. * You may study, use, and modify it for any non-commercial purpose. * You may distribute it non-commercially as long as you retain this notice. * For a commercial use license, or to purchase the book (recommended), * visit http://www.davidflanagan.com/javaexamples2. */package com.davidflanagan.examples.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 columns and lines 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 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) {