http://www.pudn.com/search_db.asp 在这里找一下吧，我也帮你找找。
一个实现了JAVA打印接口的程序文件，用于打印文本框中的内容（通过打印机）
http://download.pudn.com/downloads76/sourcecode/java/95302943PrintableTextArea.rarjava下实现可打印文档实例源码
package weichang;
import java.awt.*;
import java.awt.print.*;
import java.awt.geom.*;
import java.awt.font.*;
import javax.swing.*;
import javax.swing.text.*;
import java.util.*;
/**
* 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
double scalefactor; // How much to scale before printing
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/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 and a default scale factor. The default
* scale factor is .75 because the default fonts are overly large.
*/
public PrintableDocument(JTextComponent textComponent) {
this(textComponent, new PageFormat(), .75);
}
/**
* This constructor allows the contents of any JTextComponent to be
* printed, using any specified PageFormat object and any scaling factor.
**/
public PrintableDocument(JTextComponent textComponent, PageFormat format,
double scalefactor)
{
// Remember the page format, and ask it for the printable area
this.format = format;
this.scalefactor = scalefactor;
this.printX = format.getImageableX()/scalefactor;
this.printY = format.getImageableY()/scalefactor;
this.printWidth = format.getImageableWidth()/scalefactor;
this.printHeight = format.getImageableHeight()/scalefactor;
double paperWidth = format.getWidth()/scalefactor;
// 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((float)printWidth, (float)printHeight);
// 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(0, 0, (int)printWidth+1, (int)documentHeight+1);
// 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 many 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((float)printWidth, (float)myheight);
// 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) &amt;&amt; (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) &amt;&amt; (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
// page 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 is a
* Pageable method. 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 = ((Double)pageLengths.get(pagenum)).doubleValue();
PageFormat f = (PageFormat) format.clone();
Paper p = f.getPaper();
if (f.getOrientation() == PageFormat.PORTRAIT)
p.setImageableArea(printX*scalefactor, printY*scalefactor,
printWidth*scalefactor, pageLength*scalefactor);
else
p.setImageableArea(printY*scalefactor, printX*scalefactor,
pageLength*scalefactor, printWidth*scalefactor);
f.setPaper(p);
return f;
}
/**
* This Pageable 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 = (Graphics2D)g;
// Translate to accomodate the top and left margins
g2.translate(format.getImageableX(), format.getImageableY());
// Scale the page by the specified scaling factor
g2.scale(scalefactor, scalefactor);
// 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
if (pageIndex > 0) {
Shape originalClip = g.getClip();
g2.setClip(new Rectangle(0, (int)-printY,
(int)printWidth, (int)printY));
// Compute the header to display, measure it, then display it
String numString = "- " + (pageIndex+1) + " -";
// Get string and font measurements
FontRenderContext frc = g2.getFontRenderContext();
Rectangle2D numBounds = headerFont.getStringBounds(numString, frc);
LineMetrics metrics = headerFont.getLineMetrics(numString, frc);
g2.setFont(headerFont); // Set the font
g2.setColor(Color.black); // Print with black ink
g2.drawString(numString, // Display the string
(int)((printWidth-numBounds.getWidth())/2),
(int)(-(printY-numBounds.getHeight())/2 +
metrics.getAscent()));
g2.setClip(originalClip); // Restore the clipping region
}
// Get the staring position and length of the page within the document
double pageStart = 0.0, pageLength = printHeight;
if (pageIndex > 0)
pageStart = ((Double)pageOffsets.get(pageIndex-1)).doubleValue();
if (pageIndex < numPages-1)
pageLength = ((Double)pageLengths.get(pageIndex)).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. Because of the clipping region,
// only the desired portion of the document will actually be drawn on
// this sheet of paper.
root.paint(g2, drawRect);
// Finally return a success code
return PAGE_EXISTS;
}
public void jobprint(){
PrinterJob job=PrinterJob.getPrinterJob();
job.setPrintable(this,job.defaultPage());
if(job.printDialog()){
try {
job.print();
}
catch (PrinterException ex) {
}
}
}
/**
* 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;
}
}
}