可打印文件 : 打印 « 图形用户界面 « 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 » 图形用户界面 » 打印屏幕截图 
可打印文件
  
/*
 * 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.
 */

import java.awt.Color;
import java.awt.Container;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.font.LineMetrics;
import java.awt.geom.Rectangle2D;
import java.awt.print.PageFormat;
import java.awt.print.Pageable;
import java.awt.print.Paper;
import java.awt.print.Printable;
import java.util.ArrayList;

import javax.swing.text.BadLocationException;
import javax.swing.text.Document;
import javax.swing.text.EditorKit;
import javax.swing.text.Element;
import javax.swing.text.JTextComponent;
import javax.swing.text.Position;
import javax.swing.text.View;
import javax.swing.text.ViewFactory;

import PrintableDocument.ParentView;

/**
 * This class implements the Pageable and Printable interfaces and allows the
 * contents of any JTextComponent to be printed using the java.awt.print
 * printing API.
 */
public class PrintableDocument implements Pageable, Printable {
  View root; // The root View to be printed

  PageFormat format; // Paper plus page orientation

  int numPages; // How many pages in the document

  double printX, printY; // coordinates of upper-left of print area

  double printWidth; // Width of the printable area

  double printHeight; // Height of the printable area

  Rectangle drawRect; // The rectangle in which the document is painted

  // How lenient are we with the bottom margin in widow and orphan prevention?
  static final double MARGIN_ADJUST = .97;

  // The font we use for printing page numbers
  static final Font headerFont = new Font("Serif", Font.PLAIN, 12);

  /**
   * This constructor allows printing the contents of any JTextComponent using
   * a default PageFormat
   */
  public PrintableDocument(JTextComponent textComponent) {
    this(textComponent, new PageFormat());
  }

  /**
   * This constructor allows the contents of any JTextComponent to be printed,
   * using any specified PageFormat object
   */
  public PrintableDocument(JTextComponent textComponent, PageFormat format) {
    // Remember the page format, and ask it for the printable area
    this.format = format;
    this.printX = format.getImageableX();
    this.printY = format.getImageableY();
    this.printWidth = format.getImageableWidth();
    this.printHeight = format.getImageableHeight();
    double paperWidth = format.getWidth();

    // Get the document and its root Element from the text component
    Document document = textComponent.getDocument();
    Element rootElement = document.getDefaultRootElement();
    // Get the EditorKit and its ViewFactory from the text component
    EditorKit editorKit = textComponent.getUI().getEditorKit(textComponent);
    ViewFactory viewFactory = editorKit.getViewFactory();

    // Use the ViewFactory to create a root View object for the document
    // This is the object we'll print.
    root = viewFactory.create(rootElement);

    // The Swing text architecture requires us to call setParent() on
    // our root View before we use it for anything. In order to do this,
    // we need a View object that can serve as the parent. We use a
    // custom implementation defined below.
    root.setParent(new ParentView(root, viewFactory, textComponent));

    // Tell the view how wide the page is; it has to format itself
    // to fit within this width. The height doesn't really matter here
    root.setSize((floatprintWidth, (floatprintHeight);

    // Now that the view has formatted itself for the specified width,
    // Ask it how tall it is.
    double documentHeight = root.getPreferredSpan(View.Y_AXIS);

    // Set up the rectangle that tells the view where to draw itself
    // We'll use it in other methods of this class.
    drawRect = new Rectangle((intprintX, (intprintY, (intprintWidth,
        (intdocumentHeight);

    // Now if the document is taller than one page, we have to
    // figure out where the page breaks are.
    if (documentHeight > printHeight)
      paginate(root, drawRect);

    // Once we've broken it into pages, figure out how man pages.
    numPages = pageLengths.size() 1;
  }

  // This is the starting offset of the page we're currently working on
  double pageStart = 0;

  /**
   * This method loops through the children of the specified view, recursing
   * as necessary, and inserts pages breaks when needed. It makes a
   * rudimentary attempt to avoid "widows" and "orphans".
   */
  protected void paginate(View v, Rectangle2D allocation) {
    // Figure out how tall this view is, and tell it to allocate
    // that space among its children
    double myheight = v.getPreferredSpan(View.Y_AXIS);
    v.setSize((floatprintWidth, (floatmyheight);

    // Now loop through each of the children
    int numkids = v.getViewCount();
    for (int i = 0; i < numkids; i++) {
      View kid = v.getView(i)// this is the child we're working with
      // Figure out its size and location
      Shape kidshape = v.getChildAllocation(i, allocation);
      if (kidshape == null)
        continue;
      Rectangle2D kidbox = kidshape.getBounds2D();

      // This is the Y coordinate of the bottom of the child
      double kidpos = kidbox.getY() + kidbox.getHeight() - pageStart;

      // If this is the first child of a group, then we want to ensure
      // that it doesn't get left by itself at the bottom of a page.
      // I.e. we want to prevent "widows"
      if ((numkids > 1&& (i == 0)) {
        // If it is not near the end of the page, then just move
        // on to the next child
        if (kidpos < printY + printHeight * MARGIN_ADJUST)
          continue;

        // Otherwise, the child is near the bottom of the page, so
        // break the page before this child and place this child on
        // the new page.
        breakPage(kidbox.getY());
        continue;
      }

      // If this is the last child of a group, we don't want it to
      // appear by itself at the top of a new page, so allow it to
      // squeeze past the bottom margin if necessary. This helps to
      // prevent "orphans"
      if ((numkids > 1&& (i == numkids - 1)) {
        // If it fits normally, just move on to the next one
        if (kidpos < printY + printHeight)
          continue;

        // Otherwise, if it fits with extra space, then break the
        // at the end of the group
        if (kidpos < printY + printHeight / MARGIN_ADJUST) {
          breakPage(allocation.getY() + allocation.getHeight());
          continue;
        }
      }

      // If the child is not the first or last of a group, then we use
      // the bottom margin strictly. If the child fits on the page,
      // then move on to the next child.
      if (kidpos < printY + printHeight)
        continue;

      // If we get here, the child doesn't fit on this page. If it has
      // no children, then break the page before this child and continue.
      if (kid.getViewCount() == 0) {
        breakPage(kidbox.getY());
        continue;
      }

      // If we get here, then the child did not fit on the page, but it
      // has kids of its own, so recurse to see if any of those kids
      // will fit on the page.
      paginate(kid, kidbox);
    }
  }

  // For a document of n pages, this list stores the lengths of pages
  // 0 through n-2. The last page is assumed to have a full length
  ArrayList pageLengths = new ArrayList();

  // For a document of n pages, this list stores the starting offset of
  // pages 1 through n-1. The offset of page 0 is always 0
  ArrayList pageOffsets = new ArrayList();

  /**
   * Break a page at the specified Y coordinate. Store the necessary
   * information into the pageLengths and pageOffsets lists
   */
  void breakPage(double y) {
    double pageLength = y - pageStart - printY;
    pageStart = y - printY;
    pageLengths.add(new Double(pageLength));
    pageOffsets.add(new Double(pageStart));
  }

  /** Return the number of pages. This is a Pageable method. */
  public int getNumberOfPages() {
    return numPages;
  }

  /**
   * Return the PageFormat object for the specified page. This implementation
   * uses the computed length of the page in the returned PageFormat object.
   * The PrinterJob will use this as a clipping region, which will prevent
   * extraneous parts of the document from being drawn in the top and bottom
   * margins.
   */
  public PageFormat getPageFormat(int pagenum) {
    // On the last page, just return the user-specified page format
    if (pagenum == numPages - 1)
      return format;

    // Otherwise, look up the height of this page and return an
    // appropriate PageFormat.
    double pageLength = ((DoublepageLengths.get(pagenum)).doubleValue();
    PageFormat f = (PageFormatformat.clone();
    Paper p = f.getPaper();
    if (f.getOrientation() == PageFormat.PORTRAIT)
      p.setImageableArea(printX, printY, printWidth, pageLength);
    else
      p.setImageableArea(printY, printX, pageLength, printWidth);
    f.setPaper(p);
    return f;
  }

  /**
   * This Printable method returns the Printable object for the specified
   * page. Since this class implements both Pageable and Printable, it just
   * returns this.
   */
  public Printable getPrintable(int pagenum) {
    return this;
  }

  /**
   * This is the basic Printable method that prints a specified page
   */
  public int print(Graphics g, PageFormat format, int pageIndex) {
    // Return an error code on attempts to print past the end of the doc
    if (pageIndex >= numPages)
      return NO_SUCH_PAGE;

    // Cast the Graphics object so we can use Java2D operations
    Graphics2D g2 = (Graphics2Dg;

    // Display a page number centered in the area of the top margin.
    // Set a new clipping region so we can draw into the top margin
    // But remember the original clipping region so we can restore it
    Shape originalClip = g.getClip();
    g.setClip(new Rectangle(00(intprintWidth, (intprintY));
    // Compute the header to display, measure it, then display it
    String numString = "- " (pageIndex + 1" -";
    Rectangle2D numBounds = // Get the width and height of the string
    headerFont.getStringBounds(numString, g2.getFontRenderContext());
    LineMetrics metrics = // Get the ascent and descent of the font
    headerFont.getLineMetrics(numString, g2.getFontRenderContext());
    g.setFont(headerFont)// Set the font
    g.setColor(Color.black)// Print with black ink
    g.drawString(numString, // Display the string
        (int) (printX + (printWidth - numBounds.getWidth()) 2),
        (int) ((printY - numBounds.getHeight()) + metrics
            .getAscent()));
    g.setClip(originalClip)// Restore the clipping region

    // Figure out the staring position of the page within the document
    double pageStart = 0.0;
    if (pageIndex > 0)
      pageStart = ((DoublepageOffsets.get(pageIndex - 1)).doubleValue();

    // Scroll so that the appropriate part of the document is lined up
    // with the upper-left corner of the page
    g2.translate(0.0, -pageStart);

    // Now paint the entire document. The PrinterJob will have
    // established a clipping region, so that only the desired portion
    // of the document will actually be drawn on this sheet of paper.
    root.paint(g, drawRect);

    // Finally return a success code
    return PAGE_EXISTS;
  }

  /**
   * This inner class is a concrete implementation of View, with a couple of
   * key method implementations. An instance of this class is used as the
   * parent of the root View object we want to print
   */
  static class ParentView extends View {
    ViewFactory viewFactory; // The ViewFactory for the hierarchy of views

    Container container; // The Container for the hierarchy of views

    public ParentView(View v, ViewFactory viewFactory, Container container) {
      super(v.getElement());
      this.viewFactory = viewFactory;
      this.container = container;
    }

    // These methods return key pieces of information required by
    // the View hierarchy.
    public ViewFactory getViewFactory() {
      return viewFactory;
    }

    public Container getContainer() {
      return container;
    }

    // These methods are abstract in View, so we've got to provide
    // dummy implementations of them here, even though they're never used.
    public void paint(Graphics g, Shape allocation) {
    }

    public float getPreferredSpan(int axis) {
      return 0.0f;
    }

    public int viewToModel(float x, float y, Shape a, Position.Bias[] bias) {
      return 0;
    }

    public Shape modelToView(int pos, Shape a, Position.Bias b)
        throws BadLocationException {
      return a;
    }
  }
}



           
         
    
  
Related examples in the same category
1. 印刷代码实现打印
2. 打印图像直接打印
3. 最简单的SWT打印范例最简单的SWT打印范例
4. 打印在Java 2 : PrinterJob
5. 打印在Java :网页格式和文件
6. 打印在Java :多页
7. 打印在Java 5
8. 打印在Java 6
9. 简单的图书印刷简单的图书印刷
10. 形状打印形状打印
11. 显示打印对话框并打印
12. 打印打印区域概述打印打印区域概述
13. 打印的文本文件和打印预览打印的文本文件和打印预览
14. 可打印演示可打印演示
15. 打印图形界面组件打印图形界面组件
16. 书
17. 另一个打印演示另一个打印演示
18. 图书打印演示图书打印演示
19. 印刷组合Java 1.2和1.4之路印刷组合Java 1.2和1.4之路
20. 印刷方式Java 1.4
21. 提示打印机
22. 印刷方式Java 1.1印刷方式Java 1.1
23. 涂鸦涂鸦
24. PrintFile -打印文件命名的命令行PrintFile -打印文件命名的命令行
25. 打印到标准输出
26. PrintPanel is the base for an open-ended series of classesPrintPanel is the base for an open-ended series of classes
27. 打印演示:图书打印演示:图书
28. Print Test Print Test
29. 分页文字分页文字
30. 可打印区域
31. 实际可打印区域
32. 打印页的不同格式
33. 设置定位的打印页面
34. 打印对话框:更改默认打印机设置(默认打印机,份数,范围页)
35. 打印到文件
36. 监听打印服务状态变化
37. 打印图片
38. 覆盖的默认操作的JTextComponent
39. 显示页面格式对话框:修改默认的页面格式,如方向和纸张大小。
40. 可打印组件
www.java2java.com | Contact Us
Copyright 2010 - 2030 Java Source and Support. All rights reserved.
All other trademarks are property of their respective owners.