1 files changed, 0 insertions, 481 deletions
diff --git a/libjava/classpath/javax/swing/text/AbstractWriter.java b/libjava/classpath/javax/swing/text/AbstractWriter.java
deleted file mode 100644
index e7df26e..0000000
--- a/libjava/classpath/javax/swing/text/AbstractWriter.java
+++ /dev/null
@@ -1,481 +0,0 @@
-/* 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();
-      }
-  }
-}