A few more fixes for DefaultStyledDocument. Some structures are still broken... createFracture needs to be implemented properly to fix these problems.
I am still working on it :) 2006-01-27 Lillian Angel <[EMAIL PROTECTED]> * javax/swing/text/DefaultStyledDocument.java (insert): Moved this loop to insertUpdate. (insertUpdate): Likewise. Fixed variable names. Incremented pos if new paragraph is inserted. (split): Changed edits to use replace instead. Prevents assertion errors. (insertFirstContentTag): Removed else. (insertContentTag): Implemented else for JoinNextDirection. (createFracture): Fixed up code, still not fully complete. (insertFracture): Fixed to use return value from recreateAfterFracture. (recreateAfterFracture): Changed to return an array of the elements to be added. This prevents an assertion error.
Index: javax/swing/text/DefaultStyledDocument.java =================================================================== RCS file: /cvsroot/classpath/classpath/javax/swing/text/DefaultStyledDocument.java,v retrieving revision 1.48 diff -u -r1.48 DefaultStyledDocument.java --- javax/swing/text/DefaultStyledDocument.java 26 Jan 2006 22:09:54 -0000 1.48 +++ javax/swing/text/DefaultStyledDocument.java 27 Jan 2006 18:23:07 -0000 @@ -668,14 +668,6 @@ // Push the root and the paragraph at offset onto the element stack. edits.clear(); elementStack.clear(); - Element current = root; - int index; - while (!current.isLeaf()) - { - index = current.getElementIndex(offset); - elementStack.push(current); - current = current.getElement(index); - } insertUpdate(data); // This for loop applies all the changes that were made and updates the @@ -700,6 +692,15 @@ */ protected void insertUpdate(ElementSpec[] data) { + Element current = root; + int index; + while (!current.isLeaf()) + { + index = current.getElementIndex(offset); + elementStack.push(current); + current = current.getElement(index); + } + int i = 0; int type = data[0].getType(); if (type == ElementSpec.ContentType) @@ -707,14 +708,14 @@ // If the first tag is content we must treat it separately to allow // for joining properly to previous Elements and to ensure that // no extra LeafElements are erroneously inserted. - i = 1; insertFirstContentTag(data); pos += data[0].length; + i = 1; } else { - i = 0; createFracture(data); + i = 0; } // Handle each ElementSpec individually. @@ -734,14 +735,15 @@ case ElementSpec.JoinNextDirection: // Push the next paragraph element onto the stack so // future insertions are added to it. - int index = paragraph.getElementIndex(offset); - elementStack.push(paragraph.getElement(index)); + int ix = paragraph.getElementIndex(offset); + elementStack.push(paragraph.getElement(ix)); break; default: // Create a new paragraph and push it onto the stack. - Element current = (Element) elementStack.peek(); - Element newParagraph = insertParagraph((BranchElement) current, + Element curr = (Element) elementStack.peek(); + Element newParagraph = insertParagraph((BranchElement) curr, offset); + pos += length; elementStack.push(newParagraph); break; } @@ -802,16 +804,13 @@ added = new Element[] { res[0], ret, res[1] }; } } - Edit e = getEditForParagraphAndIndex(par, index); - e.addAddedElements(added); - e.addRemovedElements(removed); + + par.replace(index, removed.length, added); } else { ret = createBranchElement(par, null); - Element[] added = new Element[] { ret }; - Edit e = getEditForParagraphAndIndex(par, index); - e.addAddedElements(added); + par.replace(index, 0, new Element[] { ret }); } return ret; } @@ -892,8 +889,6 @@ Element newEl1 = createLeafElement(paragraph, first.getAttributes(), offset, newEndOffset); edit.addAddedElement(newEl1); - // FIXME!!! - System.out.println("INSERT FIRST CONTENT TAG FIXME"); if (current.getEndOffset() != endOffset) { // recreate all other leaves @@ -903,8 +898,7 @@ current.getEndOffset()); edit.addAddedElement(newEl2); } - else - offset = newEndOffset; + offset = newEndOffset; break; } } @@ -940,16 +934,35 @@ && (pos == target.getStartOffset() && !target.equals(lastFractured))) { Element next = paragraph.getElement(index + 1); + Element newEl = createLeafElement(paragraph, + next.getAttributes(), pos, + next.getEndOffset()); + edit.addAddedElement(newEl); + edit.addRemovedElement(next); + edit.addRemovedElement(target); + } + else + { + BranchElement parent = (BranchElement) paragraph.getParentElement(); + int i = parent.getElementIndex(pos); + BranchElement next = (BranchElement) parent.getElement(i + 1); + AttributeSet atts = tag.getAttributes(); + if (next != null) { - Element newEl = createLeafElement(paragraph, - next.getAttributes(), pos, - next.getEndOffset()); - edit.addAddedElement(newEl); - edit.addRemovedElement(next); - edit.addRemovedElement(target); + Element nextLeaf = next.getElement(0); + Edit e = getEditForParagraphAndIndex(next, 0); + Element newEl2 = createLeafElement(next, atts, pos, nextLeaf.getEndOffset()); + e.addAddedElement(newEl2); + e.addRemovedElement(nextLeaf); } } } + else if (dir != ElementSpec.OriginateDirection) + { + Element leaf = createLeafElement(paragraph, tag.getAttributes(), pos, pos + len); + edit.addAddedElement(leaf); + } + pos += len; } @@ -961,7 +974,6 @@ */ private void createFracture(ElementSpec[] data) { - System.out.println("CREATE FRACTURE FIXME!!!!!!!!!!!!"); BranchElement paragraph = (BranchElement) elementStack.peek(); int index = paragraph.getElementIndex(offset); Element child = paragraph.getElement(index); @@ -970,48 +982,12 @@ if (offset != 0) { - // FIXME: sometimes creating too many els Element newEl1 = createLeafElement(paragraph, atts, child.getStartOffset(), offset); edit.addAddedElement(newEl1); - - // add rest of leaf to next branch, if it exists. - BranchElement parent = (BranchElement) paragraph.getParentElement(); - int parIndex = parent.getElementIndex(offset); - BranchElement next = (BranchElement) parent.getElement(parIndex + 1); - if (next == null) - { - BranchElement newB = (BranchElement) createBranchElement(parent, - atts); - Element newEl2 = createLeafElement(newB, atts, offset, - child.getEndOffset()); - newB.replace(0, 0, new Element[] { newEl2 }); - Edit e = getEditForParagraphAndIndex(parent, parIndex); - e.addAddedElement(newB); - // FIXME: is this needed? elementStack.push(newB); - } - else - { - // FIXME: need to tag those elements to ignore, those created by the fracture - // don't join with those elements. - int end = child.getEndOffset(); - - Edit e = getEditForParagraphAndIndex(next, parIndex); - - // check if can join with next leaf - Element nextLeaf = next.getElement(0); - if (nextLeaf != null && nextLeaf.isLeaf() - && nextLeaf.getAttributes().isEqual(atts)) - { - end = nextLeaf.getEndOffset(); - e.addRemovedElement(nextLeaf); - } - - Element newEl2 = createLeafElement(next, atts, offset, end); - e.addAddedElement(newEl2); - } } edit.addRemovedElement(child); + // FIXME: may be incomplete } /** @@ -1209,7 +1191,10 @@ Edit edit = getEditForParagraphAndIndex(parent, parentIndex); edit.addAddedElements(added); edit.addRemovedElements(removed); - recreateAfterFracture(removed, parent, 1, rightBranch.getEndOffset()); + added = recreateAfterFracture(removed, parent, 1, + rightBranch.getEndOffset()); + Edit edit2 = getEditForParagraphAndIndex(parent, parent.getElementCount()); + edit2.addAddedElements(added); elementStack.push(rightBranch); lastFractured = rightFracturedLeaf; } @@ -1228,8 +1213,9 @@ * where to start recreating from * @param startOffset - * the offset of the first element + * @return the array of added elements */ - private void recreateAfterFracture(Element[] recreate, + private Element[] recreateAfterFracture(Element[] recreate, BranchElement parent, int startFrom, int startOffset) { @@ -1249,8 +1235,10 @@ for (int k = 0; k < bSize; k++) { Element bCurr = curr.getElement(k); - recreateAfterFracture(new Element[] { bCurr }, br, 0, + Element[] add = recreateAfterFracture(new Element[] { bCurr }, br, 0, startOffset); + br.replace(0, 0, add); + } added[j] = br; } @@ -1258,8 +1246,7 @@ j++; } - Edit edit = getEditForParagraphAndIndex(parent, parent.getElementCount()); - edit.addAddedElements(added); + return added; } /** @@ -1448,6 +1435,33 @@ addedElements[i] = (Element) added.elementAt(i); return addedElements; } + + /** + * Checks if e is already in the vector. + * + * @param e - the Element to look for + * @param v - the vector to search + * @return true if e is in v. + */ + private boolean contains(Vector v, Element e) + { + if (e == null) + return false; + + int i = v.size(); + for (int j = 0; j < i; j++) + { + Element e1 = (Element) v.get(j); + if ((e1 != null) && (e1.getAttributes().isEqual(e.getAttributes())) + && (e1.getName().equals(e.getName())) + && (e1.getStartOffset() == e.getStartOffset()) + && (e1.getEndOffset() == e.getEndOffset()) + && (e1.getParentElement().equals(e.getParentElement())) + && (e1.getElementCount() == e.getElementCount())) + return true; + } + return false; + } /** * Adds one Element to the vector of removed Elements. @@ -1457,7 +1471,7 @@ */ public void addRemovedElement(Element e) { - if (!removed.contains(e)) + if (!contains(removed, e)) removed.add(e); } @@ -1473,7 +1487,7 @@ return; for (int i = 0; i < e.length; i++) { - if (!removed.contains(e[i])) + if (!contains(removed, e[i])) removed.add(e[i]); } } @@ -1486,7 +1500,7 @@ */ public void addAddedElement(Element e) { - if (!added.contains(e)) + if (!contains(added, e)) added.add(e); } @@ -1502,7 +1516,7 @@ return; for (int i = 0; i < e.length; i++) { - if (!added.contains(e[i])) + if (!contains(added, e[i])) added.add(e[i]); } }