/*
* Copyright (c) 1998, 2006, 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 javax.swing.text;
import java.io.Writer;
import java.io.IOException;
import java.util.Enumeration;
/**
* AbstractWriter is an abstract class that actually
* does the work of writing out the element tree
* including the attributes. In terms of how much is
* written out per line, the writer defaults to 100.
* But this value can be set by subclasses.
*
* @author Sunita Mani
*/
public abstract class AbstractWriter {
private ElementIterator it;
private Writer out;
private int indentLevel = 0;
private int indentSpace = 2;
private Document doc = null;
private int maxLineLength = 100;
private int currLength = 0;
private int startOffset = 0;
private int endOffset = 0;
// If (indentLevel * indentSpace) becomes >= maxLineLength, this will
// get incremened instead of indentLevel to avoid indenting going greater
// than line length.
private int offsetIndent = 0;
/**
* String used for end of line. If the Document has the property
* EndOfLineStringProperty, it will be used for newlines. Otherwise
* the System property line.separator will be used. The line separator
* can also be set.
*/
private String lineSeparator;
/**
* True indicates that when writing, the line can be split, false
* indicates that even if the line is > than max line length it should
* not be split.
*/
private boolean canWrapLines;
/**
* True while the current line is empty. This will remain true after
* indenting.
*/
private boolean isLineEmpty;
/**
* Used when indenting. Will contain the spaces.
*/
private char[] indentChars;
/**
* Used when writing out a string.
*/
private char[] tempChars;
/**
* This is used in <code>writeLineSeparator</code> instead of
* tempChars. If tempChars were used it would mean write couldn't invoke
* <code>writeLineSeparator</code> as it might have been passed
* tempChars.
*/
private char[] newlineChars;
/**
* Used for writing text.
*/
private Segment segment;
/**
* How the text packages models newlines.
* @see #getLineSeparator
*/
protected static final char NEWLINE = '\n';
/**
* Creates a new AbstractWriter.
* Initializes the ElementIterator with the default
* root of the document.
*
* @param w a Writer.
* @param doc a Document
*/
protected AbstractWriter(Writer w, Document doc) {
this(w, doc, 0, doc.getLength());
}
/**
* Creates a new AbstractWriter.
* Initializes the ElementIterator with the
* element passed in.
*
* @param w a Writer
* @param doc an Element
* @param pos The location in the document to fetch the
* content.
* @param len The amount to write out.
*/
protected AbstractWriter(Writer w, Document doc, int pos, int len) {
this.doc = doc;
it = new ElementIterator(doc.getDefaultRootElement());
out = w;
startOffset = pos;
endOffset = pos + len;
Object docNewline = doc.getProperty(DefaultEditorKit.
EndOfLineStringProperty);
if (docNewline instanceof String) {
setLineSeparator((String)docNewline);
}
else {
String newline = null;
try {
newline = System.getProperty("line.separator");
} catch (SecurityException se) {}
if (newline == null) {
// Should not get here, but if we do it means we could not
// find a newline string, use \n in this case.
newline = "\n";
}
setLineSeparator(newline);
}
canWrapLines = true;
}
/**
* Creates a new AbstractWriter.
* Initializes the ElementIterator with the
* element passed in.
*
* @param w a Writer
* @param root an Element
*/
protected AbstractWriter(Writer w, Element root) {
this(w, root, 0, root.getEndOffset());
}
/**
* Creates a new AbstractWriter.
* Initializes the ElementIterator with the
* element passed in.
*
* @param w a Writer
* @param root an Element
* @param pos The location in the document to fetch the
* content.
* @param len The amount to write out.
*/
protected AbstractWriter(Writer w, Element root, int pos, int len) {
this.doc = root.getDocument();
it = new ElementIterator(root);
out = w;
startOffset = pos;
endOffset = pos + len;
canWrapLines = true;
}
/**
* Returns the first offset to be output.
*
* @since 1.3
*/
public int getStartOffset() {
return startOffset;
}
/**
* Returns the last offset to be output.
*
* @since 1.3
*/
public int getEndOffset() {
return endOffset;
}
/**
* Fetches the ElementIterator.
*
* @return the ElementIterator.
*/
protected ElementIterator getElementIterator() {
return it;
}
/**
* Returns the Writer that is used to output the content.
*
* @since 1.3
*/
protected Writer getWriter() {
return out;
}
/**
* Fetches the document.
*
* @return the Document.
*/
protected Document getDocument() {
return doc;
}
/**
* This method determines whether the current element
* is in the range specified. When no range is specified,
* the range is initialized to be the entire document.
* inRange() returns true if the range specified intersects
* with the element's range.
*
* @param next an Element.
* @return boolean that indicates whether the element
* is in the range.
*/
protected boolean inRange(Element next) {
int startOffset = getStartOffset();
int endOffset = getEndOffset();
if ((next.getStartOffset() >= startOffset &&
next.getStartOffset() < endOffset) ||
(startOffset >= next.getStartOffset() &&
startOffset < next.getEndOffset())) {
return true;
}
return false;
}
/**
* This abstract method needs to be implemented
* by subclasses. Its responsibility is to
* iterate over the elements and use the write()
* methods to generate output in the desired format.
*/
abstract protected void write() throws IOException, BadLocationException;
/**
* Returns the text associated with the element.
* The assumption here is that the element is a
* leaf element. Throws a BadLocationException
* when encountered.
*
* @param elem an <code>Element</code>
* @exception BadLocationException if pos represents an invalid
* location within the document
* @return the text as a <code>String</code>
*/
protected String getText(Element elem) throws BadLocationException {
return doc.getText(elem.getStartOffset(),
elem.getEndOffset() - elem.getStartOffset());
}
/**
* Writes out text. If a range is specified when the constructor
* is invoked, then only the appropriate range of text is written
* out.
*
* @param elem an Element.
* @exception IOException on any I/O error
* @exception BadLocationException if pos represents an invalid
* location within the document.
*/
protected void text(Element elem) throws BadLocationException,
IOException {
int start = Math.max(getStartOffset(), elem.getStartOffset());
int end = Math.min(getEndOffset(), elem.getEndOffset());
if (start < end) {
if (segment == null) {
segment = new Segment();
}
getDocument().getText(start, end - start, segment);
if (segment.count > 0) {
write(segment.array, segment.offset, segment.count);
}
}
}
/**
* Enables subclasses to set the number of characters they
* want written per line. The default is 100.
*
* @param l the maximum line length.
*/
protected void setLineLength(int l) {
maxLineLength = l;
}
/**
* Returns the maximum line length.
*
* @since 1.3
*/
protected int getLineLength() {
return maxLineLength;
}
/**
* Sets the current line length.
*
* @since 1.3
*/
protected void setCurrentLineLength(int length) {
currLength = length;
isLineEmpty = (currLength == 0);
}
/**
* Returns the current line length.
*
* @since 1.3
*/
protected int getCurrentLineLength() {
return currLength;
}
/**
* Returns true if the current line should be considered empty. This
* is true when <code>getCurrentLineLength</code> == 0 ||
* <code>indent</code> has been invoked on an empty line.
*
* @since 1.3
*/
protected boolean isLineEmpty() {
return isLineEmpty;
}
/**
* Sets whether or not lines can be wrapped. This can be toggled
* during the writing of lines. For example, outputting HTML might
* set this to false when outputting a quoted string.
*
* @since 1.3
*/
protected void setCanWrapLines(boolean newValue) {
canWrapLines = newValue;
}
/**
* Returns whether or not the lines can be wrapped. If this is false
* no lineSeparator's will be output.
*
* @since 1.3
*/
protected boolean getCanWrapLines() {
return canWrapLines;
}
/**
* Enables subclasses to specify how many spaces an indent
* maps to. When indentation takes place, the indent level
* is multiplied by this mapping. The default is 2.
*
* @param space an int representing the space to indent mapping.
*/
protected void setIndentSpace(int space) {
indentSpace = space;
}
/**
* Returns the amount of space to indent.
*
* @since 1.3
*/
protected int getIndentSpace() {
return indentSpace;
}
/**
* Sets the String used to reprsent newlines. This is initialized
* in the constructor from either the Document, or the System property
* line.separator.
*
* @since 1.3
*/
public void setLineSeparator(String value) {
lineSeparator = value;
}
/**
* Returns the string used to represent newlines.
*
* @since 1.3
*/
public String getLineSeparator() {
return lineSeparator;
}
/**
* Increments the indent level. If indenting would cause
* <code>getIndentSpace()</code> *<code>getIndentLevel()</code> to be >
* than <code>getLineLength()</code> this will not cause an indent.
*/
protected void incrIndent() {
// Only increment to a certain point.
if (offsetIndent > 0) {
offsetIndent++;
}
else {
if (++indentLevel * getIndentSpace() >= getLineLength()) {
offsetIndent++;
--indentLevel;
}
}
}
/**
* Decrements the indent level.
*/
protected void decrIndent() {
if (offsetIndent > 0) {
--offsetIndent;
}
else {
indentLevel--;
}
}
/**
* Returns the current indentation level. That is, the number of times
* <code>incrIndent</code> has been invoked minus the number of times
* <code>decrIndent</code> has been invoked.
*
* @since 1.3
*/
protected int getIndentLevel() {
return indentLevel;
}
/**
* Does indentation. The number of spaces written
* out is indent level times the space to map mapping. If the current
* line is empty, this will not make it so that the current line is
* still considered empty.
*
* @exception IOException on any I/O error
*/
protected void indent() throws IOException {
int max = getIndentLevel() * getIndentSpace();
if (indentChars == null || max > indentChars.length) {
indentChars = new char[max];
for (int counter = 0; counter < max; counter++) {
indentChars[counter] = ' ';
}
}
int length = getCurrentLineLength();
boolean wasEmpty = isLineEmpty();
output(indentChars, 0, max);
if (wasEmpty && length == 0) {
isLineEmpty = true;
}
}
/**
* Writes out a character. This is implemented to invoke
* the <code>write</code> method that takes a char[].
*
* @param ch a char.
* @exception IOException on any I/O error
*/
protected void write(char ch) throws IOException {
if (tempChars == null) {
tempChars = new char[128];
}
tempChars[0] = ch;
write(tempChars, 0, 1);
}
/**
* Writes out a string. This is implemented to invoke the
* <code>write</code> method that takes a char[].
*
* @param content a String.
* @exception IOException on any I/O error
*/
protected void write(String content) throws IOException {
if (content == null) {
return;
}
int size = content.length();
if (tempChars == null || tempChars.length < size) {
tempChars = new char[size];
}
content.getChars(0, size, tempChars, 0);
write(tempChars, 0, size);
}
/**
* Writes the line separator. This invokes <code>output</code> directly
* as well as setting the <code>lineLength</code> to 0.
*
* @since 1.3
*/
protected void writeLineSeparator() throws IOException {
String newline = getLineSeparator();
int length = newline.length();
if (newlineChars == null || newlineChars.length < length) {
newlineChars = new char[length];
}
newline.getChars(0, length, newlineChars, 0);
output(newlineChars, 0, length);
setCurrentLineLength(0);
}
/**
* All write methods call into this one. If <code>getCanWrapLines()</code>
* returns false, this will call <code>output</code> with each sequence
* of <code>chars</code> that doesn't contain a NEWLINE, followed
* by a call to <code>writeLineSeparator</code>. On the other hand,
* if <code>getCanWrapLines()</code> returns true, this will split the
* string, as necessary, so <code>getLineLength</code> is honored.
* The only exception is if the current string contains no whitespace,
* and won't fit in which case the line length will exceed
* <code>getLineLength</code>.
*
* @since 1.3
*/
protected void write(char[] chars, int startIndex, int length)
throws IOException {
if (!getCanWrapLines()) {
// We can not break string, just track if a newline
// is in it.
int lastIndex = startIndex;
int endIndex = startIndex + length;
int newlineIndex = indexOf(chars, NEWLINE, startIndex, endIndex);
while (newlineIndex != -1) {
if (newlineIndex > lastIndex) {
output(chars, lastIndex, newlineIndex - lastIndex);
}
writeLineSeparator();
lastIndex = newlineIndex + 1;
newlineIndex = indexOf(chars, '\n', lastIndex, endIndex);
}
if (lastIndex < endIndex) {
output(chars, lastIndex, endIndex - lastIndex);
}
}
else {
// We can break chars if the length exceeds maxLength.
int lastIndex = startIndex;
int endIndex = startIndex + length;
int lineLength = getCurrentLineLength();
int maxLength = getLineLength();
while (lastIndex < endIndex) {
int newlineIndex = indexOf(chars, NEWLINE, lastIndex,
endIndex);
boolean needsNewline = false;
boolean forceNewLine = false;
lineLength = getCurrentLineLength();
if (newlineIndex != -1 && (lineLength +
(newlineIndex - lastIndex)) < maxLength) {
if (newlineIndex > lastIndex) {
output(chars, lastIndex, newlineIndex - lastIndex);
}
lastIndex = newlineIndex + 1;
forceNewLine = true;
}
else if (newlineIndex == -1 && (lineLength +
(endIndex - lastIndex)) < maxLength) {
if (endIndex > lastIndex) {
output(chars, lastIndex, endIndex - lastIndex);
}
lastIndex = endIndex;
}
else {
// Need to break chars, find a place to split chars at,
// from lastIndex to endIndex,
// or maxLength - lineLength whichever is smaller
int breakPoint = -1;
int maxBreak = Math.min(endIndex - lastIndex,
maxLength - lineLength - 1);
int counter = 0;
while (counter < maxBreak) {
if (Character.isWhitespace(chars[counter +
lastIndex])) {
breakPoint = counter;
}
counter++;
}
if (breakPoint != -1) {
// Found a place to break at.
breakPoint += lastIndex + 1;
output(chars, lastIndex, breakPoint - lastIndex);
lastIndex = breakPoint;
needsNewline = true;
}
else {
// No where good to break.
// find the next whitespace, or write out the
// whole string.
// maxBreak will be negative if current line too
// long.
counter = Math.max(0, maxBreak);
maxBreak = endIndex - lastIndex;
while (counter < maxBreak) {
if (Character.isWhitespace(chars[counter +
lastIndex])) {
breakPoint = counter;
break;
}
counter++;
}
if (breakPoint == -1) {
output(chars, lastIndex, endIndex - lastIndex);
breakPoint = endIndex;
}
else {
breakPoint += lastIndex;
if (chars[breakPoint] == NEWLINE) {
output(chars, lastIndex, breakPoint++ -
lastIndex);
forceNewLine = true;
}
else {
output(chars, lastIndex, ++breakPoint -
lastIndex);
needsNewline = true;
}
}
lastIndex = breakPoint;
}
}
if (forceNewLine || needsNewline || lastIndex < endIndex) {
writeLineSeparator();
if (lastIndex < endIndex || !forceNewLine) {
indent();
}
}
}
}
}
/**
* Writes out the set of attributes as " <name>=<value>"
* pairs. It throws an IOException when encountered.
*
* @param attr an AttributeSet.
* @exception IOException on any I/O error
*/
protected void writeAttributes(AttributeSet attr) throws IOException {
Enumeration names = attr.getAttributeNames();
while (names.hasMoreElements()) {
Object name = names.nextElement();
write(" " + name + "=" + attr.getAttribute(name));
}
}
/**
* The last stop in writing out content. All the write methods eventually
* make it to this method, which invokes <code>write</code> on the
* Writer.
* <p>This method also updates the line length based on
* <code>length</code>. If this is invoked to output a newline, the
* current line length will need to be reset as will no longer be
* valid. If it is up to the caller to do this. Use
* <code>writeLineSeparator</code> to write out a newline, which will
* property update the current line length.
*
* @since 1.3
*/
protected void output(char[] content, int start, int length)
throws IOException {
getWriter().write(content, start, length);
setCurrentLineLength(getCurrentLineLength() + length);
}
/**
* Support method to locate an occurence of a particular character.
*/
private int indexOf(char[] chars, char sChar, int startIndex,
int endIndex) {
while(startIndex < endIndex) {
if (chars[startIndex] == sChar) {
return startIndex;
}
startIndex++;
}
return -1;
}
}