Retro68/gcc/libjava/classpath/javax/swing/text/AbstractWriter.java

/* AbstractWriter.java --
   Copyright (C) 2005 Free Software Foundation, Inc.

This file is part of GNU Classpath.

GNU Classpath is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Classpath 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 for more details.

You should have received a copy of the GNU General Public License
along with GNU Classpath; see the file COPYING.  If not, write to the
Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301 USA.

Linking this library statically or dynamically with other modules is
making a combined work based on this library.  Thus, the terms and
conditions of the GNU General Public License cover the whole
combination.

As a special exception, the copyright holders of this library give you
permission to link this library with independent modules to produce an
executable, regardless of the license terms of these independent
modules, and to copy and distribute the resulting executable under
terms of your choice, provided that you also meet, for each linked
independent module, the terms and conditions of the license of that
module.  An independent module is a module which is not derived from
or based on this library.  If you modify this library, you may extend
this exception to your version of the library, but you are not
obligated to do so.  If you do not wish to do so, delete this
exception statement from your version. */

package javax.swing.text;

import java.io.IOException;
import java.io.Writer;
import java.util.Arrays;
import java.util.Enumeration;

/**
 * This is an abstract base class for writing Document instances to a
 * Writer.  A concrete subclass must implement a method to iterate
 * over the Elements of the Document and correctly format them.
 */
public abstract class AbstractWriter
{
  /**
   * The default line separator character.
   * @specnote although this is a constant, it is not static in the JDK
   */
  protected static final char NEWLINE = '\n';

  // Where we write.
  private Writer writer;
  // How we iterate over the document.
  private ElementIterator iter;
  // The document over which we iterate.
  private Document document;
  // Maximum number of characters per line.
  private int maxLineLength = 100;
  // Number of characters we have currently written.
  private int lineLength;
  // True if we can apply line wrapping.
  private boolean canWrapLines; // FIXME default?
  // The number of spaces per indentation level.
  private int indentSpace = 2;
  // The current indentation level.
  private int indentLevel;
  // True if we have indented this line.
  private boolean indented;
  // Starting offset in document.
  private int startOffset;
  // Ending offset in document.
  private int endOffset;
  // The line separator string.
  private String lineSeparator = "" + NEWLINE;
  // The characters making up the line separator.
  private char[] lineSeparatorChars = lineSeparator.toCharArray();

  /**
   * Create a new AbstractWriter with the indicated Writer and
   * Document.  The full range of the Document will be used.  The
   * internal ElementIterator will be initialized with the Document's
   * root node.
   */
  protected AbstractWriter(Writer writer, Document doc)
  {
    this.writer = writer;
    this.iter = new ElementIterator(doc);
    this.document = doc;
    this.startOffset = 0;
    this.endOffset = doc.getLength();
  }

  /**
   * Create a new AbstractWriter with the indicated Writer and
   * Document.  The full range of the Document will be used.  The
   * internal ElementIterator will be initialized with the Document's
   * root node.
   */
  protected AbstractWriter(Writer writer, Document doc, int pos, int len)
  {
    this.writer = writer;
    this.iter = new ElementIterator(doc);
    this.document = doc;
    this.startOffset = pos;
    this.endOffset = pos + len;
  }

  /**
   * Create a new AbstractWriter with the indicated Writer and
   * Element.  The full range of the Element will be used.
   */
  protected AbstractWriter(Writer writer, Element elt)
  {
    this.writer = writer;
    this.iter = new ElementIterator(elt);
    this.document = elt.getDocument();
    this.startOffset = elt.getStartOffset();
    this.endOffset = elt.getEndOffset();
  }

  /**
   * Create a new AbstractWriter with the indicated Writer and
   * Element.  The full range of the Element will be used.  The range
   * will be limited to the indicated range of the Document.
   */
  protected AbstractWriter(Writer writer, Element elt, int pos, int len)
  {
    this.writer = writer;
    this.iter = new ElementIterator(elt);
    this.document = elt.getDocument();
    this.startOffset = pos;
    this.endOffset = pos + len;
  }

  /**
   * Return the ElementIterator for this writer.
   */
  protected ElementIterator getElementIterator()
  {
    return iter;
  }

  /**
   * Return the Writer to which we are writing.
   * @since 1.3
   */
  protected Writer getWriter()
  {
    return writer;
  }

  /**
   * Return this writer's Document.
   */
  protected Document getDocument()
  {
    return document;
  }

  /**
   * This method must be overridden by a concrete subclass.  It is
   * responsible for iterating over the Elements of the Document and
   * writing them out.
   */
  protected abstract void write() throws IOException, BadLocationException;

  /**
   * Return the text of the Document that is associated with the given
   * Element.  If the Element is not a leaf Element, this will throw
   * BadLocationException.
   *
   * @throws BadLocationException if the element is not a leaf
   */
  protected String getText(Element elt) throws BadLocationException
  {
    if (! elt.isLeaf())
      throw new BadLocationException("Element is not a leaf",
                                     elt.getStartOffset());
    return document.getText(elt.getStartOffset(),
                            elt.getEndOffset() - elt.getStartOffset());
  }

  /**
   * This method calls Writer.write on the indicated data, and updates
   * the current line length.  This method does not look for newlines
   * in the written data; the caller is responsible for that.
   *
   * @since 1.3
   */
  protected void output(char[] data, int start, int len) throws IOException
  {
    writer.write(data, start, len);
    lineLength += len;
  }

  /**
   * Write a line separator using the output method, and then reset
   * the current line length.
   *
   * @since 1.3
   */
  protected void writeLineSeparator() throws IOException
  {
    output(lineSeparatorChars, 0, lineSeparatorChars.length);
    lineLength = 0;
    indented = false;
  }

  /**
   * Write a single character.
   */
  protected void write(char ch) throws IOException
  {
    write(new char[] { ch }, 0, 1);
  }

  /**
   * Write a String.
   */
  protected void write(String s) throws IOException
  {
    char[] v = s.toCharArray();
    write(v, 0, v.length);
  }

  /**
   * Write a character array to the output Writer, properly handling
   * newlines and, if needed, wrapping lines as they are output.
   * @since 1.3
   */
  protected void write(char[] data, int start, int len) throws IOException
  {
    if (getCanWrapLines())
      {
        // FIXME: should we be handling newlines specially here?
        for (int i = 0; i < len; )
          {
            int start_i = i;
            // Find next space.
            while (i < len && data[start + i] != ' ')
              ++i;
            if (i < len && lineLength + i - start_i >= maxLineLength)
              writeLineSeparator();
            else if (i < len)
              {
                // Write the trailing space.
                ++i;
              }
            // Write out the text.
            output(data, start + start_i, start + i - start_i);
          }
      }
    else
      {
        int saved_i = start;
        for (int i = start; i < start + len; ++i)
          {
            if (data[i] == NEWLINE)
              {
                output(data, saved_i, i - saved_i);
                writeLineSeparator();
              }
          }
        if (saved_i < start + len - 1)
          output(data, saved_i, start + len - saved_i);
      }
  }

  /**
   * Indent this line by emitting spaces, according to the current
   * indent level and the current number of spaces per indent.  After
   * this method is called, the current line is no longer considered
   * to be empty, even if no spaces are actually written.
   */
  protected void indent() throws IOException
  {
    int spaces = indentLevel * indentSpace;
    if (spaces > 0)
      {
        char[] v = new char[spaces];
        Arrays.fill(v, ' ');
        write(v, 0, v.length);
      }
    indented = true;
  }

  /**
   * Return the index of the Document at which output starts.
   * @since 1.3
   */
  public int getStartOffset()
  {
    return startOffset;
  }

  /**
   * Return the index of the Document at which output ends.
   * @since 1.3
   */
  public int getEndOffset()
  {
    return endOffset;
  }

  /**
   * Return true if the Element's range overlaps our desired output
   * range; false otherwise.
   */
  protected boolean inRange(Element elt)
  {
    int eltStart = elt.getStartOffset();
    int eltEnd = elt.getEndOffset();
    return ((eltStart >= startOffset && eltStart < endOffset)
            || (eltEnd >= startOffset && eltEnd < endOffset));
  }

  /**
   * Output the text of the indicated Element, properly clipping it to
   * the range of the Document specified when the AbstractWriter was
   * created.
   */
  protected void text(Element elt) throws BadLocationException, IOException
  {
    int eltStart = elt.getStartOffset();
    int eltEnd = elt.getEndOffset();

    eltStart = Math.max(eltStart, startOffset);
    eltEnd = Math.min(eltEnd, endOffset);
    write(document.getText(eltStart, eltEnd));
  }

  /**
   * Set the maximum line length.
   */
  protected void setLineLength(int maxLineLength)
  {
    this.maxLineLength = maxLineLength;
  }

  /**
   * Return the maximum line length.
   * @since 1.3
   */
  protected int getLineLength()
  {
    return maxLineLength;
  }

  /**
   * Set the current line length.
   * @since 1.3
   */
  protected void setCurrentLineLength(int lineLength)
  {
    this.lineLength = lineLength;
  }

  /**
   * Return the current line length.
   * @since 1.3
   */
  protected int getCurrentLineLength()
  {
    return lineLength;
  }

  /**
   * Return true if the line is empty, false otherwise.  The line is
   * empty if nothing has been written since the last newline, and
   * indent has not been invoked.
   */
  protected boolean isLineEmpty()
  {
    return lineLength == 0 && ! indented;
  }

  /**
   * Set the flag indicating whether lines will wrap.  This affects
   * the behavior of write().
   * @since 1.3
   */
  protected void setCanWrapLines(boolean canWrapLines)
  {
    this.canWrapLines = canWrapLines;
  }

  /**
   * Return true if lines printed via write() will wrap, false
   * otherwise.
   * @since 1.3
   */
  protected boolean getCanWrapLines()
  {
    return canWrapLines;
  }

  /**
   * Set the number of spaces per indent level.
   * @since 1.3
   */
  protected void setIndentSpace(int indentSpace)
  {
    this.indentSpace = indentSpace;
  }

  /**
   * Return the number of spaces per indent level.
   * @since 1.3
   */
  protected int getIndentSpace()
  {
    return indentSpace;
  }

  /**
   * Set the current line separator.
   * @since 1.3
   */
  public void setLineSeparator(String lineSeparator)
  {
    this.lineSeparator = lineSeparator;
    this.lineSeparatorChars = lineSeparator.toCharArray();
  }

  /**
   * Return the current line separator.
   * @since 1.3
   */
  public String getLineSeparator()
  {
    return lineSeparator;
  }

  /**
   * Increment the indent level.
   */
  protected void incrIndent()
  {
    ++indentLevel;
  }

  /**
   * Decrement the indent level.
   */
  protected void decrIndent()
  {
    --indentLevel;
  }

  /**
   * Return the current indent level.
   * @since 1.3
   */
  protected int getIndentLevel()
  {
    return indentLevel;
  }

  /**
   * Print the given AttributeSet as a sequence of assignment-like
   * strings, e.g. "key=value".
   */
  protected void writeAttributes(AttributeSet attrs) throws IOException
  {
    Enumeration e = attrs.getAttributeNames();
    while (e.hasMoreElements())
      {
        Object name = e.nextElement();
        Object val = attrs.getAttribute(name);
        write(name + "=" + val);
        writeLineSeparator();
      }
  }
}