PlainDocument.java

/*
 * Copyright (c) 1997, 2014, 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.
 */
packagejavax.swing.text;

importjava.util.Vector;

/**
 * A plain document that maintains no character attributes. The
 * default element structure for this document is a map of the lines in
 * the text. The Element returned by getDefaultRootElement is
 * a map of the lines, and each child element represents a line.
 * This model does not maintain any character level attributes,
 * but each line can be tagged with an arbitrary set of attributes.
 * Line to offset, and offset to line translations can be quickly
 * performed using the default root element. The structure information
 * of the DocumentEvent's fired by edits will indicate the line
 * structure changes.
 * <p>
 * The default content storage management is performed by a
 * gapped buffer implementation (GapContent). It supports
 * editing reasonably large documents with good efficiency when
 * the edits are contiguous or clustered, as is typical.
 * <p>
 * <strong>Warning:</strong>
 * Serialized objects of this class will not be compatible with
 * future Swing releases. The current serialization support is
 * appropriate for short term storage or RMI between applications running
 * the same version of Swing. As of 1.4, support for long term storage
 * of all JavaBeans
 * has been added to the <code>java.beans</code> package.
 * Please see {@link java.beans.XMLEncoder}.
 *
 * @author Timothy Prinzing
 * @see Document
 * @see AbstractDocument
 */
@SuppressWarnings("serial") // Same-version serialization only
publicclassPlainDocumentextendsAbstractDocument {

/**
 * Name of the attribute that specifies the tab
 * size for tabs contained in the content. The
 * type for the value is Integer.
 */
publicstaticfinalStringtabSizeAttribute = "tabSize";

/**
 * Name of the attribute that specifies the maximum
 * length of a line, if there is a maximum length.
 * The type for the value is Integer.
 */
publicstaticfinalStringlineLimitAttribute = "lineLimit";

/**
 * Constructs a plain text document. A default model using
 * <code>GapContent</code> is constructed and set.
 */
publicPlainDocument() {
this(newGapContent());
 }

/**
 * Constructs a plain text document. A default root element is created,
 * and the tab size set to 8.
 *
 * @param c the container for the content
 */
publicPlainDocument(Contentc) {
super(c);
putProperty(tabSizeAttribute, Integer.valueOf(8));
defaultRoot = createDefaultRoot();
 }

/**
 * Inserts some content into the document.
 * Inserting content causes a write lock to be held while the
 * actual changes are taking place, followed by notification
 * to the observers on the thread that grabbed the write lock.
 * <p>
 * This method is thread safe, although most Swing methods
 * are not. Please see
 * <A HREF="https://docs.oracle.com/javase/tutorial/uiswing/concurrency/index.html">Concurrency
 * in Swing</A> for more information.
 *
 * @param offs the starting offset &gt;= 0
 * @param str the string to insert; does nothing with null/empty strings
 * @param a the attributes for the inserted content
 * @throws BadLocationException the given insert position is not a valid
 * position within the document
 * @see Document#insertString
 */
publicvoidinsertString(intoffs, Stringstr, AttributeSeta) throwsBadLocationException {
// fields don't want to have multiple lines. We may provide a field-specific
// model in the future in which case the filtering logic here will no longer
// be needed.
ObjectfilterNewlines = getProperty("filterNewlines");
if ((filterNewlinesinstanceofBoolean) && filterNewlines.equals(Boolean.TRUE)) {
if ((str != null) && (str.indexOf('\n') >= 0)) {
StringBuilderfiltered = newStringBuilder(str);
intn = filtered.length();
for (inti = 0; i < n; i++) {
if (filtered.charAt(i) == '\n') {
filtered.setCharAt(i, ' ');
 }
 }
str = filtered.toString();
 }
 }
super.insertString(offs, str, a);
 }

/**
 * Gets the default root element for the document model.
 *
 * @return the root
 * @see Document#getDefaultRootElement
 */
publicElementgetDefaultRootElement() {
returndefaultRoot;
 }

/**
 * Creates the root element to be used to represent the
 * default document structure.
 *
 * @return the element base
 */
protectedAbstractElementcreateDefaultRoot() {
BranchElementmap = (BranchElement) createBranchElement(null, null);
Elementline = createLeafElement(map, null, 0, 1);
Element[] lines = newElement[1];
lines[0] = line;
map.replace(0, 0, lines);
returnmap;
 }

/**
 * Get the paragraph element containing the given position. Since this
 * document only models lines, it returns the line instead.
 */
publicElementgetParagraphElement(intpos){
ElementlineMap = getDefaultRootElement();
returnlineMap.getElement( lineMap.getElementIndex( pos ) );
 }

/**
 * Updates document structure as a result of text insertion. This
 * will happen within a write lock. Since this document simply
 * maps out lines, we refresh the line map.
 *
 * @param chng the change event describing the dit
 * @param attr the set of attributes for the inserted text
 */
protectedvoidinsertUpdate(DefaultDocumentEventchng, AttributeSetattr) {
removed.removeAllElements();
added.removeAllElements();
BranchElementlineMap = (BranchElement) getDefaultRootElement();
intoffset = chng.getOffset();
intlength = chng.getLength();
if (offset > 0) {
offset -= 1;
length += 1;
 }
intindex = lineMap.getElementIndex(offset);
ElementrmCandidate = lineMap.getElement(index);
intrmOffs0 = rmCandidate.getStartOffset();
intrmOffs1 = rmCandidate.getEndOffset();
intlastOffset = rmOffs0;
try {
if (s == null) {
s = newSegment();
 }
getContent().getChars(offset, length, s);
booleanhasBreaks = false;
for (inti = 0; i < length; i++) {
charc = s.array[s.offset + i];
if (c == '\n') {
intbreakOffset = offset + i + 1;
added.addElement(createLeafElement(lineMap, null, lastOffset, breakOffset));
lastOffset = breakOffset;
hasBreaks = true;
 }
 }
if (hasBreaks) {
removed.addElement(rmCandidate);
if ((offset + length == rmOffs1) && (lastOffset != rmOffs1) &&
 ((index+1) < lineMap.getElementCount())) {
Elemente = lineMap.getElement(index+1);
removed.addElement(e);
rmOffs1 = e.getEndOffset();
 }
if (lastOffset < rmOffs1) {
added.addElement(createLeafElement(lineMap, null, lastOffset, rmOffs1));
 }

Element[] aelems = newElement[added.size()];
added.copyInto(aelems);
Element[] relems = newElement[removed.size()];
removed.copyInto(relems);
ElementEditee = newElementEdit(lineMap, index, relems, aelems);
chng.addEdit(ee);
lineMap.replace(index, relems.length, aelems);
 }
if (Utilities.isComposedTextAttributeDefined(attr)) {
insertComposedTextUpdate(chng, attr);
 }
 } catch (BadLocationExceptione) {
thrownewError("Internal error: " + e.toString());
 }
super.insertUpdate(chng, attr);
 }

/**
 * Updates any document structure as a result of text removal.
 * This will happen within a write lock. Since the structure
 * represents a line map, this just checks to see if the
 * removal spans lines. If it does, the two lines outside
 * of the removal area are joined together.
 *
 * @param chng the change event describing the edit
 */
protectedvoidremoveUpdate(DefaultDocumentEventchng) {
removed.removeAllElements();
BranchElementmap = (BranchElement) getDefaultRootElement();
intoffset = chng.getOffset();
intlength = chng.getLength();
intline0 = map.getElementIndex(offset);
intline1 = map.getElementIndex(offset + length);
if (line0 != line1) {
// a line was removed
for (inti = line0; i <= line1; i++) {
removed.addElement(map.getElement(i));
 }
intp0 = map.getElement(line0).getStartOffset();
intp1 = map.getElement(line1).getEndOffset();
Element[] aelems = newElement[1];
aelems[0] = createLeafElement(map, null, p0, p1);
Element[] relems = newElement[removed.size()];
removed.copyInto(relems);
ElementEditee = newElementEdit(map, line0, relems, aelems);
chng.addEdit(ee);
map.replace(line0, relems.length, aelems);
 } else {
//Check for the composed text element
Elementline = map.getElement(line0);
if (!line.isLeaf()) {
Elementleaf = line.getElement(line.getElementIndex(offset));
if (Utilities.isComposedTextElement(leaf)) {
Element[] aelem = newElement[1];
aelem[0] = createLeafElement(map, null,
line.getStartOffset(), line.getEndOffset());
Element[] relem = newElement[1];
relem[0] = line;
ElementEditee = newElementEdit(map, line0, relem, aelem);
chng.addEdit(ee);
map.replace(line0, 1, aelem);
 }
 }
 }
super.removeUpdate(chng);
 }

//
// Inserts the composed text of an input method. The line element
// where the composed text is inserted into becomes an branch element
// which contains leaf elements of the composed text and the text
// backing store.
//
privatevoidinsertComposedTextUpdate(DefaultDocumentEventchng, AttributeSetattr) {
added.removeAllElements();
BranchElementlineMap = (BranchElement) getDefaultRootElement();
intoffset = chng.getOffset();
intlength = chng.getLength();
intindex = lineMap.getElementIndex(offset);
Elementelem = lineMap.getElement(index);
intelemStart = elem.getStartOffset();
intelemEnd = elem.getEndOffset();
BranchElement[] abelem = newBranchElement[1];
abelem[0] = (BranchElement) createBranchElement(lineMap, null);
Element[] relem = newElement[1];
relem[0] = elem;
if (elemStart != offset)
added.addElement(createLeafElement(abelem[0], null, elemStart, offset));
added.addElement(createLeafElement(abelem[0], attr, offset, offset+length));
if (elemEnd != offset+length)
added.addElement(createLeafElement(abelem[0], null, offset+length, elemEnd));
Element[] alelem = newElement[added.size()];
added.copyInto(alelem);
ElementEditee = newElementEdit(lineMap, index, relem, abelem);
chng.addEdit(ee);

abelem[0].replace(0, 0, alelem);
lineMap.replace(index, 1, abelem);
 }

privateAbstractElementdefaultRoot;
privateVector<Element> added = newVector<Element>();
privateVector<Element> removed = newVector<Element>();
privatetransientSegments;
}