Back to index...

	/*
	* Copyright (c) 2005, 2011, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package sun.swing.text;

	import java.awt.ComponentOrientation;
	import java.awt.Dimension;
	import java.awt.Font;
	import java.awt.FontMetrics;
	import java.awt.Graphics;
	import java.awt.Graphics2D;
	import java.awt.Insets;
	import java.awt.Rectangle;
	import java.awt.Component;
	import java.awt.Container;
	import java.awt.font.FontRenderContext;
	import java.awt.print.PageFormat;
	import java.awt.print.Printable;
	import java.awt.print.PrinterException;
	import java.text.MessageFormat;
	import java.util.ArrayList;
	import java.util.Collections;
	import java.util.List;
	import java.util.concurrent.Callable;
	import java.util.concurrent.ExecutionException;
	import java.util.concurrent.FutureTask;
	import java.util.concurrent.atomic.AtomicReference;

	import javax.swing.*;
	import javax.swing.border.Border;
	import javax.swing.border.TitledBorder;
	import javax.swing.text.BadLocationException;
	import javax.swing.text.JTextComponent;
	import javax.swing.text.Document;
	import javax.swing.text.EditorKit;
	import javax.swing.text.AbstractDocument;
	import javax.swing.text.html.HTMLDocument;
	import javax.swing.text.html.HTML;

	import sun.font.FontDesignMetrics;

	import sun.swing.text.html.FrameEditorPaneTag;

	/**
	* An implementation of {@code Printable} to print {@code JTextComponent} with
	* the header and footer.
	*
	* <h1>
	* WARNING: this class is to be used in
	* javax.swing.text.JTextComponent only.
	* </h1>
	*
	* <p>
	* The implementation creates a new {@code JTextComponent} ({@code printShell})
	* to print the content using the {@code Document}, {@code EditorKit} and
	* rendering-affecting properties from the original {@code JTextComponent}.
	*
	* <p>
	* {@code printShell} is laid out on the first {@code print} invocation.
	*
	* <p>
	* This class can be used on any thread. Part of the implementation is executed
	* on the EDT though.
	*
	* @author Igor Kushnirskiy
	*
	* @since 1.6
	*/
	public class TextComponentPrintable implements CountingPrintable {


	private static final int LIST_SIZE = 1000;

	private boolean isLayouted = false;

	/*
	* The text component to print.
	*/
	private final JTextComponent textComponentToPrint;

	/*
	* The FontRenderContext to layout and print with
	*/
	private final AtomicReference<FontRenderContext> frc =
	new AtomicReference<FontRenderContext>(null);

	/**
	* Special text component used to print to the printer.
	*/
	private final JTextComponent printShell;

	private final MessageFormat headerFormat;
	private final MessageFormat footerFormat;

	private static final float HEADER_FONT_SIZE = 18.0f;
	private static final float FOOTER_FONT_SIZE = 12.0f;

	private final Font headerFont;
	private final Font footerFont;

	/**
	* stores metrics for the unhandled rows. The only metrics we need are
	* yStart and yEnd when row is handled by updatePagesMetrics it is removed
	* from the list. Thus the head of the list is the fist row to handle.
	*
	* sorted
	*/
	private final List<IntegerSegment> rowsMetrics;

	/**
	* thread-safe list for storing pages metrics. The only metrics we need are
	* yStart and yEnd.
	* It has to be thread-safe since metrics are calculated on
	* the printing thread and accessed on the EDT thread.
	*
	* sorted
	*/
	private final List<IntegerSegment> pagesMetrics;

	/**
	* Returns {@code TextComponentPrintable} to print {@code textComponent}.
	*
	* @param textComponent {@code JTextComponent} to print
	* @param headerFormat the page header, or {@code null} for none
	* @param footerFormat the page footer, or {@code null} for none
	* @return {@code TextComponentPrintable} to print {@code textComponent}
	*/
	public static Printable getPrintable(final JTextComponent textComponent,
	final MessageFormat headerFormat,
	final MessageFormat footerFormat) {

	if (textComponent instanceof JEditorPane
	&& isFrameSetDocument(textComponent.getDocument())) {
	//for document with frames we create one printable per
	//frame and merge them with the CompoundPrintable.
	List<JEditorPane> frames = getFrames((JEditorPane) textComponent);
	List<CountingPrintable> printables =
	new ArrayList<CountingPrintable>();
	for (JEditorPane frame : frames) {
	printables.add((CountingPrintable)
	getPrintable(frame, headerFormat, footerFormat));
	}
	return new CompoundPrintable(printables);
	} else {
	return new TextComponentPrintable(textComponent,
	headerFormat, footerFormat);
	}
	}

	/**
	* Checks whether the document has frames. Only HTMLDocument might
	* have frames.
	*
	* @param document the {@code Document} to check
	* @return {@code true} if the {@code document} has frames
	*/
	private static boolean isFrameSetDocument(final Document document) {
	boolean ret = false;
	if (document instanceof HTMLDocument) {
	HTMLDocument htmlDocument = (HTMLDocument)document;
	if (htmlDocument.getIterator(HTML.Tag.FRAME).isValid()) {
	ret = true;
	}
	}
	return ret;
	}


	/**
	* Returns frames under the {@code editor}.
	* The frames are created if necessary.
	*
	* @param editor the {@JEditorPane} to find the frames for
	* @return list of all frames
	*/
	private static List<JEditorPane> getFrames(final JEditorPane editor) {
	List<JEditorPane> list = new ArrayList<JEditorPane>();
	getFrames(editor, list);
	if (list.size() == 0) {
	//the frames have not been created yet.
	//let's trigger the frames creation.
	createFrames(editor);
	getFrames(editor, list);
	}
	return list;
	}

	/**
	* Adds all {@code JEditorPanes} under {@code container} tagged by {@code
	* FrameEditorPaneTag} to the {@code list}. It adds only top
	* level {@code JEditorPanes}. For instance if there is a frame
	* inside the frame it will return the top frame only.
	*
	* @param c the container to find all frames under
	* @param list {@code List} to append the results too
	*/
	private static void getFrames(final Container container, List<JEditorPane> list) {
	for (Component c : container.getComponents()) {
	if (c instanceof FrameEditorPaneTag
	&& c instanceof JEditorPane ) { //it should be always JEditorPane
	list.add((JEditorPane) c);
	} else {
	if (c instanceof Container) {
	getFrames((Container) c, list);
	}
	}
	}
	}

	/**
	* Triggers the frames creation for {@code JEditorPane}
	*
	* @param editor the {@code JEditorPane} to create frames for
	*/
	private static void createFrames(final JEditorPane editor) {
	Runnable doCreateFrames =
	new Runnable() {
	public void run() {
	final int WIDTH = 500;
	final int HEIGHT = 500;
	CellRendererPane rendererPane = new CellRendererPane();
	rendererPane.add(editor);
	//the values do not matter
	//we only need to get frames created
	rendererPane.setSize(WIDTH, HEIGHT);
	};
	};
	if (SwingUtilities.isEventDispatchThread()) {
	doCreateFrames.run();
	} else {
	try {
	SwingUtilities.invokeAndWait(doCreateFrames);
	} catch (Exception e) {
	if (e instanceof RuntimeException) {
	throw (RuntimeException) e;
	} else {
	throw new RuntimeException(e);
	}
	}
	}
	}

	/**
	* Constructs {@code TextComponentPrintable} to print {@code JTextComponent}
	* {@code textComponent} with {@code headerFormat} and {@code footerFormat}.
	*
	* @param textComponent {@code JTextComponent} to print
	* @param headerFormat the page header or {@code null} for none
	* @param footerFormat the page footer or {@code null} for none
	*/
	private TextComponentPrintable(JTextComponent textComponent,
	MessageFormat headerFormat,
	MessageFormat footerFormat) {
	this.textComponentToPrint = textComponent;
	this.headerFormat = headerFormat;
	this.footerFormat = footerFormat;
	headerFont = textComponent.getFont().deriveFont(Font.BOLD,
	HEADER_FONT_SIZE);
	footerFont = textComponent.getFont().deriveFont(Font.PLAIN,
	FOOTER_FONT_SIZE);
	this.pagesMetrics =
	Collections.synchronizedList(new ArrayList<IntegerSegment>());
	this.rowsMetrics = new ArrayList<IntegerSegment>(LIST_SIZE);
	this.printShell = createPrintShell(textComponent);
	}


	/**
	* creates a printShell.
	* It creates closest text component to {@code textComponent}
	* which uses {@code frc} from the {@code TextComponentPrintable}
	* for the {@code getFontMetrics} method.
	*
	* @param textComponent {@code JTextComponent} to create a
	* printShell for
	* @return the print shell
	*/
	private JTextComponent createPrintShell(final JTextComponent textComponent) {
	if (SwingUtilities.isEventDispatchThread()) {
	return createPrintShellOnEDT(textComponent);
	} else {
	FutureTask<JTextComponent> futureCreateShell =
	new FutureTask<JTextComponent>(
	new Callable<JTextComponent>() {
	public JTextComponent call() throws Exception {
	return createPrintShellOnEDT(textComponent);
	}
	});
	SwingUtilities.invokeLater(futureCreateShell);
	try {
	return futureCreateShell.get();
	} catch (InterruptedException e) {
	throw new RuntimeException(e);
	} catch (ExecutionException e) {
	Throwable cause = e.getCause();
	if (cause instanceof Error) {
	throw (Error) cause;
	}
	if (cause instanceof RuntimeException) {
	throw (RuntimeException) cause;
	}
	throw new AssertionError(cause);
	}
	}
	}
	private JTextComponent createPrintShellOnEDT(final JTextComponent textComponent) {
	assert SwingUtilities.isEventDispatchThread();

	JTextComponent ret = null;
	if (textComponent instanceof JPasswordField) {
	ret =
	new JPasswordField() {
	{
	setEchoChar(((JPasswordField) textComponent).getEchoChar());
	setHorizontalAlignment(
	((JTextField) textComponent).getHorizontalAlignment());
	}
	@Override
	public FontMetrics getFontMetrics(Font font) {
	return (frc.get() == null)
	? super.getFontMetrics(font)
	: FontDesignMetrics.getMetrics(font, frc.get());
	}
	};
	} else if (textComponent instanceof JTextField) {
	ret =
	new JTextField() {
	{
	setHorizontalAlignment(
	((JTextField) textComponent).getHorizontalAlignment());
	}
	@Override
	public FontMetrics getFontMetrics(Font font) {
	return (frc.get() == null)
	? super.getFontMetrics(font)
	: FontDesignMetrics.getMetrics(font, frc.get());
	}
	};
	} else if (textComponent instanceof JTextArea) {
	ret =
	new JTextArea() {
	{
	JTextArea textArea = (JTextArea) textComponent;
	setLineWrap(textArea.getLineWrap());
	setWrapStyleWord(textArea.getWrapStyleWord());
	setTabSize(textArea.getTabSize());
	}
	@Override
	public FontMetrics getFontMetrics(Font font) {
	return (frc.get() == null)
	? super.getFontMetrics(font)
	: FontDesignMetrics.getMetrics(font, frc.get());
	}
	};
	} else if (textComponent instanceof JTextPane) {
	ret =
	new JTextPane() {
	@Override
	public FontMetrics getFontMetrics(Font font) {
	return (frc.get() == null)
	? super.getFontMetrics(font)
	: FontDesignMetrics.getMetrics(font, frc.get());
	}
	@Override
	public EditorKit getEditorKit() {
	if (getDocument() == textComponent.getDocument()) {
	return ((JTextPane) textComponent).getEditorKit();
	} else {
	return super.getEditorKit();
	}
	}
	};
	} else if (textComponent instanceof JEditorPane) {
	ret =
	new JEditorPane() {
	@Override
	public FontMetrics getFontMetrics(Font font) {
	return (frc.get() == null)
	? super.getFontMetrics(font)
	: FontDesignMetrics.getMetrics(font, frc.get());
	}
	@Override
	public EditorKit getEditorKit() {
	if (getDocument() == textComponent.getDocument()) {
	return ((JEditorPane) textComponent).getEditorKit();
	} else {
	return super.getEditorKit();
	}
	}
	};
	}
	//want to occupy the whole width and height by text
	ret.setBorder(null);

	//set properties from the component to print
	ret.setOpaque(textComponent.isOpaque());
	ret.setEditable(textComponent.isEditable());
	ret.setEnabled(textComponent.isEnabled());
	ret.setFont(textComponent.getFont());
	ret.setBackground(textComponent.getBackground());
	ret.setForeground(textComponent.getForeground());
	ret.setComponentOrientation(
	textComponent.getComponentOrientation());

	if (ret instanceof JEditorPane) {
	ret.putClientProperty(JEditorPane.HONOR_DISPLAY_PROPERTIES,
	textComponent.getClientProperty(
	JEditorPane.HONOR_DISPLAY_PROPERTIES));
	ret.putClientProperty(JEditorPane.W3C_LENGTH_UNITS,
	textComponent.getClientProperty(JEditorPane.W3C_LENGTH_UNITS));
	ret.putClientProperty("charset",
	textComponent.getClientProperty("charset"));
	}
	ret.setDocument(textComponent.getDocument());
	return ret;
	}




	/**
	* Returns the number of pages in this printable.
	* <p>
	* This number is defined only after {@code print} returns NO_SUCH_PAGE.
	*
	* @return the number of pages.
	*/
	public int getNumberOfPages() {
	return pagesMetrics.size();
	}

	/**
	* See Printable.print for the API description.
	*
	* There are two parts in the implementation.
	* First part (print) is to be called on the printing thread.
	* Second part (printOnEDT) is to be called on the EDT only.
	*
	* print triggers printOnEDT
	*/
	public int print(final Graphics graphics,
	final PageFormat pf,
	final int pageIndex) throws PrinterException {
	if (!isLayouted) {
	if (graphics instanceof Graphics2D) {
	frc.set(((Graphics2D)graphics).getFontRenderContext());
	}
	layout((int)Math.floor(pf.getImageableWidth()));
	calculateRowsMetrics();
	}
	int ret;
	if (!SwingUtilities.isEventDispatchThread()) {
	Callable<Integer> doPrintOnEDT = new Callable<Integer>() {
	public Integer call() throws Exception {
	return printOnEDT(graphics, pf, pageIndex);
	}
	};
	FutureTask<Integer> futurePrintOnEDT =
	new FutureTask<Integer>(doPrintOnEDT);
	SwingUtilities.invokeLater(futurePrintOnEDT);
	try {
	ret = futurePrintOnEDT.get();
	} catch (InterruptedException e) {
	throw new RuntimeException(e);
	} catch (ExecutionException e) {
	Throwable cause = e.getCause();
	if (cause instanceof PrinterException) {
	throw (PrinterException)cause;
	} else if (cause instanceof RuntimeException) {
	throw (RuntimeException) cause;
	} else if (cause instanceof Error) {
	throw (Error) cause;
	} else {
	throw new RuntimeException(cause);
	}
	}
	} else {
	ret = printOnEDT(graphics, pf, pageIndex);
	}
	return ret;
	}


	/**
	* The EDT part of the print method.
	*
	* This method is to be called on the EDT only. Layout should be done before
	* calling this method.
	*/
	private int printOnEDT(final Graphics graphics,
	final PageFormat pf,
	final int pageIndex) throws PrinterException {
	assert SwingUtilities.isEventDispatchThread();
	Border border = BorderFactory.createEmptyBorder();
	//handle header and footer
	if (headerFormat != null \|\| footerFormat != null) {
	//Printable page enumeration is 0 base. We need 1 based.
	Object[] formatArg = new Object[]{Integer.valueOf(pageIndex + 1)};
	if (headerFormat != null) {
	border = new TitledBorder(border,
	headerFormat.format(formatArg),
	TitledBorder.CENTER, TitledBorder.ABOVE_TOP,
	headerFont, printShell.getForeground());
	}
	if (footerFormat != null) {
	border = new TitledBorder(border,
	footerFormat.format(formatArg),
	TitledBorder.CENTER, TitledBorder.BELOW_BOTTOM,
	footerFont, printShell.getForeground());
	}
	}
	Insets borderInsets = border.getBorderInsets(printShell);
	updatePagesMetrics(pageIndex,
	(int)Math.floor(pf.getImageableHeight()) - borderInsets.top
	- borderInsets.bottom);

	if (pagesMetrics.size() <= pageIndex) {
	return NO_SUCH_PAGE;
	}

	Graphics2D g2d = (Graphics2D)graphics.create();

	g2d.translate(pf.getImageableX(), pf.getImageableY());
	border.paintBorder(printShell, g2d, 0, 0,
	(int)Math.floor(pf.getImageableWidth()),
	(int)Math.floor(pf.getImageableHeight()));

	g2d.translate(0, borderInsets.top);
	//want to clip only vertically
	Rectangle clip = new Rectangle(0, 0,
	(int) pf.getWidth(),
	pagesMetrics.get(pageIndex).end
	- pagesMetrics.get(pageIndex).start + 1);

	g2d.clip(clip);
	int xStart = 0;
	if (ComponentOrientation.RIGHT_TO_LEFT ==
	printShell.getComponentOrientation()) {
	xStart = (int) pf.getImageableWidth() - printShell.getWidth();
	}
	g2d.translate(xStart, - pagesMetrics.get(pageIndex).start);
	printShell.print(g2d);

	g2d.dispose();

	return Printable.PAGE_EXISTS;
	}


	private boolean needReadLock = false;

	/**
	* Tries to release document's readlock
	*
	* Note: Not to be called on the EDT.
	*/
	private void releaseReadLock() {
	assert ! SwingUtilities.isEventDispatchThread();
	Document document = textComponentToPrint.getDocument();
	if (document instanceof AbstractDocument) {
	try {
	((AbstractDocument) document).readUnlock();
	needReadLock = true;
	} catch (Error ignore) {
	// readUnlock() might throw StateInvariantError
	}
	}
	}


	/**
	* Tries to acquire document's readLock if it was released
	* in releaseReadLock() method.
	*
	* Note: Not to be called on the EDT.
	*/
	private void acquireReadLock() {
	assert ! SwingUtilities.isEventDispatchThread();
	if (needReadLock) {
	try {
	/*
	* wait until all the EDT events are processed
	* some of the document changes are asynchronous
	* we need to make sure we get the lock after those changes
	*/
	SwingUtilities.invokeAndWait(
	new Runnable() {
	public void run() {
	}
	});
	} catch (InterruptedException ignore) {
	} catch (java.lang.reflect.InvocationTargetException ignore) {
	}
	Document document = textComponentToPrint.getDocument();
	((AbstractDocument) document).readLock();
	needReadLock = false;
	}
	}

	/**
	* Prepares {@code printShell} for printing.
	*
	* Sets properties from the component to print.
	* Sets width and FontRenderContext.
	*
	* Triggers Views creation for the printShell.
	*
	* There are two parts in the implementation.
	* First part (layout) is to be called on the printing thread.
	* Second part (layoutOnEDT) is to be called on the EDT only.
	*
	* {@code layout} triggers {@code layoutOnEDT}.
	*
	* @param width width to layout the text for
	*/
	private void layout(final int width) {
	if (!SwingUtilities.isEventDispatchThread()) {
	Callable<Object> doLayoutOnEDT = new Callable<Object>() {
	public Object call() throws Exception {
	layoutOnEDT(width);
	return null;
	}
	};
	FutureTask<Object> futureLayoutOnEDT = new FutureTask<Object>(
	doLayoutOnEDT);

	/*
	* We need to release document's readlock while printShell is
	* initializing
	*/
	releaseReadLock();
	SwingUtilities.invokeLater(futureLayoutOnEDT);
	try {
	futureLayoutOnEDT.get();
	} catch (InterruptedException e) {
	throw new RuntimeException(e);
	} catch (ExecutionException e) {
	Throwable cause = e.getCause();
	if (cause instanceof RuntimeException) {
	throw (RuntimeException) cause;
	} else if (cause instanceof Error) {
	throw (Error) cause;
	} else {
	throw new RuntimeException(cause);
	}
	} finally {
	acquireReadLock();
	}
	} else {
	layoutOnEDT(width);
	}

	isLayouted = true;
	}

	/**
	* The EDT part of layout method.
	*
	* This method is to be called on the EDT only.
	*/
	private void layoutOnEDT(final int width) {
	assert SwingUtilities.isEventDispatchThread();
	//need to have big value but smaller than MAX_VALUE otherwise
	//printing goes south due to overflow somewhere
	final int HUGE_INTEGER = Integer.MAX_VALUE - 1000;

	CellRendererPane rendererPane = new CellRendererPane();

	//need to use JViewport since text is layouted to the viewPort width
	//otherwise it will be layouted to the maximum text width
	JViewport viewport = new JViewport();
	viewport.setBorder(null);
	Dimension size = new Dimension(width, HUGE_INTEGER);

	//JTextField is a special case
	//it layouts text in the middle by Y
	if (printShell instanceof JTextField) {
	size =
	new Dimension(size.width, printShell.getPreferredSize().height);
	}
	printShell.setSize(size);
	viewport.setComponentOrientation(printShell.getComponentOrientation());
	viewport.setSize(size);
	viewport.add(printShell);
	rendererPane.add(viewport);
	}

	/**
	* Calculates pageMetrics for the pages up to the {@code pageIndex} using
	* {@code rowsMetrics}.
	* Metrics are stored in the {@code pagesMetrics}.
	*
	* @param pageIndex the page to update the metrics for
	* @param pageHeight the page height
	*/
	private void updatePagesMetrics(final int pageIndex, final int pageHeight) {
	while (pageIndex >= pagesMetrics.size() && !rowsMetrics.isEmpty()) {
	// add one page to the pageMetrics
	int lastPage = pagesMetrics.size() - 1;
	int pageStart = (lastPage >= 0)
	? pagesMetrics.get(lastPage).end + 1
	: 0;
	int rowIndex;
	for (rowIndex = 0;
	rowIndex < rowsMetrics.size()
	&& (rowsMetrics.get(rowIndex).end - pageStart + 1)
	<= pageHeight;
	rowIndex++) {
	}
	if (rowIndex == 0) {
	// can not fit a single row
	// need to split
	pagesMetrics.add(
	new IntegerSegment(pageStart, pageStart + pageHeight - 1));
	} else {
	rowIndex--;
	pagesMetrics.add(new IntegerSegment(pageStart,
	rowsMetrics.get(rowIndex).end));
	for (int i = 0; i <= rowIndex; i++) {
	rowsMetrics.remove(0);
	}
	}
	}
	}

	/**
	* Calculates rowsMetrics for the document. The result is stored
	* in the {@code rowsMetrics}.
	*
	* Two steps process.
	* First step is to find yStart and yEnd for the every document position.
	* Second step is to merge all intersected segments ( [yStart, yEnd] ).
	*/
	private void calculateRowsMetrics() {
	final int documentLength = printShell.getDocument().getLength();
	List<IntegerSegment> documentMetrics = new ArrayList<IntegerSegment>(LIST_SIZE);
	Rectangle rect;
	for (int i = 0, previousY = -1, previousHeight = -1; i < documentLength;
	i++) {
	try {
	rect = printShell.modelToView(i);
	if (rect != null) {
	int y = (int) rect.getY();
	int height = (int) rect.getHeight();
	if (height != 0
	&& (y != previousY \|\| height != previousHeight)) {
	/*
	* we do not store the same value as previous. in our
	* documents it is often for consequent positons to have
	* the same modelToView y and height.
	*/
	previousY = y;
	previousHeight = height;
	documentMetrics.add(new IntegerSegment(y, y + height - 1));
	}
	}
	} catch (BadLocationException e) {
	assert false;
	}
	}
	/*
	* Merge all intersected segments.
	*/
	Collections.sort(documentMetrics);
	int yStart = Integer.MIN_VALUE;
	int yEnd = Integer.MIN_VALUE;
	for (IntegerSegment segment : documentMetrics) {
	if (yEnd < segment.start) {
	if (yEnd != Integer.MIN_VALUE) {
	rowsMetrics.add(new IntegerSegment(yStart, yEnd));
	}
	yStart = segment.start;
	yEnd = segment.end;
	} else {
	yEnd = segment.end;
	}
	}
	if (yEnd != Integer.MIN_VALUE) {
	rowsMetrics.add(new IntegerSegment(yStart, yEnd));
	}
	}

	/**
	* Class to represent segment of integers.
	* we do not call it Segment to avoid confusion with
	* javax.swing.text.Segment
	*/
	private static class IntegerSegment implements Comparable<IntegerSegment> {
	final int start;
	final int end;

	IntegerSegment(int start, int end) {
	this.start = start;
	this.end = end;
	}

	public int compareTo(IntegerSegment object) {
	int startsDelta = start - object.start;
	return (startsDelta != 0) ? startsDelta : end - object.end;
	}

	@Override
	public boolean equals(Object obj) {
	if (obj instanceof IntegerSegment) {
	return compareTo((IntegerSegment) obj) == 0;
	} else {
	return false;
	}
	}

	@Override
	public int hashCode() {
	// from the "Effective Java: Programming Language Guide"
	int result = 17;
	result = 37 * result + start;
	result = 37 * result + end;
	return result;
	}

	@Override
	public String toString() {
	return "IntegerSegment [" + start + ", " + end + "]";
	}
	}
	}

Back to index...