A character output stream that sends output to a printer : 文件通道 « 文件输入输出 « Java

En
Java
1. 图形用户界面
2. 三维图形动画
3. 高级图形
4. 蚂蚁编译
5. Apache类库
6. 统计图
7. 
8. 集合数据结构
9. 数据类型
10. 数据库JDBC
11. 设计模式
12. 开发相关类
13. EJB3
14. 电子邮件
15. 事件
16. 文件输入输出
17. 游戏
18. 泛型
19. GWT
20. Hibernate
21. 本地化
22. J2EE平台
23. 基于J2ME
24. JDK-6
25. JNDI的LDAP
26. JPA
27. JSP技术
28. JSTL
29. 语言基础知识
30. 网络协议
31. PDF格式RTF格式
32. 映射
33. 常规表达式
34. 脚本
35. 安全
36. Servlets
37. Spring
38. Swing组件
39. 图形用户界面
40. SWT-JFace-Eclipse
41. 线程
42. 应用程序
43. Velocity
44. Web服务SOA
45. 可扩展标记语言
Java 教程
Java » 文件输入输出 » 文件通道屏幕截图 
A character output stream that sends output to a printer
 

/*
 * Copyright (c) 2004 David Flanagan.  All rights reserved.
 * This code is from the book Java Examples in a Nutshell, 3nd 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,
 * including teaching and use in open-source projects.
 * You may distribute it non-commercially as long as you retain this notice.
 * For a commercial use license, or to purchase the book, 
 * please visit http://www.davidflanagan.com/javaexamples3.
 */
//package je3.print;
import java.awt.Button;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Panel;
import java.awt.PrintJob;
import java.awt.Toolkit;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.io.FileReader;
import java.io.PrintWriter;
import java.io.Writer;
import java.text.DateFormat;
import java.util.Date;
import java.util.Properties;
import java.util.TimeZone;

/**
 * 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"07)) {
      // 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 += (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 - w2, 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(20050);
        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();
    }
  }
}

   
  
Related examples in the same category
1. 执行简单的复制操作
2. 使用FileChannel写入文件
3. 使用FileChannels来存取文件
4. 写入映射文件
5. 使用NIO复制文件
6. Get FileChannel from FileOutputStream and FileInputStream
7. FileChannel之间转移
8. Read bytes from the specified channel, decode them using the specified Charset, and write the resulting characters to the specified writer
9. Demonstrates file locking and simple file read and write operations using java.nio.channels.FileChannel
10. 创建一个只读存储器映射文件
11. 创建一个读写内存映射文件
12. 建立交流的渠道
13. 创建一个inputstream的通道
14. 创建写时拷贝内存映射文件
www.java2java.com | Contact Us
Copyright 2010 - 2030 Java Source and Support. All rights reserved.
All other trademarks are property of their respective owners.