Java 类javax.swing.undo.UndoableEdit 实例源码

@Override
public boolean addEdit(UndoableEdit anEdit) {
    if (super.addEdit(anEdit)) {
        if (mergeEditIndex >= MERGE_INDEX_NOT_INITIALIZED) { // Valid or not inited
            if (anEdit instanceof BaseDocumentEvent) {
                mergeEditIndex = size() - 1;
            } else if (anEdit.getClass() != BaseDocument.AtomicCompoundEdit.class &&
                !CaretUndo.isCaretUndoEdit(anEdit)
            ) {
                mergeEditIndex = MERGE_PROHIBITED; // Do not allow merging if there are unknown undoable edits
            }
        }
        return true;
    }
    return false;
}

/** Try to determine whether this event can replace the old one.
* This is used to batch the one-letter modifications into larger
* parts (words) and undoing/redoing them at once.
* This method returns true whether 
*/
public @Override boolean replaceEdit(UndoableEdit anEdit) {
    BaseDocument doc = (BaseDocument)getDocument();
    if (anEdit instanceof BaseDocument.AtomicCompoundEdit) {
        BaseDocument.AtomicCompoundEdit compEdit
                = (BaseDocument.AtomicCompoundEdit)anEdit;

        BaseDocumentEvent aMergeEdit = compEdit.getMergeEdit();
        if (!doc.undoMergeReset && aMergeEdit != null) {
            if (canMerge(aMergeEdit)) {
                previous = anEdit;
                return true;
            }
        }
    } else if (anEdit instanceof BaseDocumentEvent) {
        BaseDocumentEvent evt = (BaseDocumentEvent)anEdit;

        if (!doc.undoMergeReset && canMerge(evt)) {
            previous = anEdit;
            return true;
        }
    }
    doc.undoMergeReset = false;
    return false;
}

public @Override void die() {
       // Super of die()
int size = edits.size();
for (int i = size-1; i >= 0; i--)
{
    UndoableEdit e = (UndoableEdit)edits.elementAt(i);
    e.die();
}

       alive2 = false;
       // End super of die()

       if (previous != null) {
           previous.die();
           previous = null;
       }
   }

public void testWrapping() throws Exception {
        MimePath mimePath = MimePath.EMPTY;
        MockMimeLookup.setInstances(mimePath, new TestingUndoableEditWrapper(), new TestingUndoableEditWrapper2());
        CESEnv env = new CESEnv();
        Document doc = env.support.openDocument();
//        doc.addUndoableEditListener(new UndoableEditListener() {
//            @Override
//            public void undoableEditHappened(UndoableEditEvent e) {
//                UndoableEdit edit = e.getEdit();
//            }
//        });
        doc.insertString(0, "Test", null);
        Class wrapEditClass = TestingUndoableEditWrapper.WrapCompoundEdit.class;
        assertNotNull(NbDocument.getEditToBeUndoneOfType(env.support, wrapEditClass));
        Class wrapEditClass2 = TestingUndoableEditWrapper2.WrapCompoundEdit2.class;
        assertNotNull(NbDocument.getEditToBeUndoneOfType(env.support, wrapEditClass2));

        // A trick to get whole edit
        UndoableEdit wholeEdit = NbDocument.getEditToBeUndoneOfType(env.support, UndoableEdit.class);
        assertTrue(wholeEdit instanceof List);
        @SuppressWarnings("unchecked")
        List<? extends UndoableEdit> listEdit = (List<? extends UndoableEdit>) wholeEdit;
        assertEquals(3, listEdit.size());
        assertEquals(wrapEditClass, listEdit.get(1).getClass());
        assertEquals(wrapEditClass2, listEdit.get(2).getClass());
    }

@Test
public void testAddCaretUndoableEdit() throws Exception {
    final JEditorPane pane = new JEditorPane("text/plain", "Haf");
    //final CompoundEdit compoundEdit = new CompoundEdit();
    final boolean[] editAdded = { false };
    final Document doc = pane.getDocument();
    doc.putProperty(CustomUndoDocument.class, new CustomUndoDocument() {
        @Override
        public void addUndoableEdit(UndoableEdit edit) {
            editAdded[0] = true;
        }
    });
    final EditorCaret editorCaret = new EditorCaret();
    SwingUtilities.invokeAndWait(new Runnable() {
        @Override
        public void run() {
            pane.setCaret(editorCaret);
            EditorUtilities.addCaretUndoableEdit(doc, editorCaret);
        }
    });

    assertTrue(editAdded[0]);
}

@Override
   public String getUndoPresentationName() {
UndoableEdit last = lastEdit();
if (last != null) {
    return last.getUndoPresentationName();
} else {
           String name = getPresentationName();
           if (!"".equals(name)) {
               name = UIManager.getString("AbstractUndoableEdit.undoText")
                       + " " + name;
           } else {
               name = UIManager.getString("AbstractUndoableEdit.undoText");
           }

           return name;
}
   }

@Override
   public String getRedoPresentationName() {
UndoableEdit last = lastEdit();
if (last != null) {
    return last.getRedoPresentationName();
} else {
           String name = getPresentationName();
           if (!"".equals(name)) {
               name = UIManager.getString("AbstractUndoableEdit.redoText")
                       + " " + name;
           } else {
               name = UIManager.getString("AbstractUndoableEdit.redoText");
           }

           return name;
}
   }

private static <T extends UndoableEdit> T getEditToBeUndoneRedoneOfType(EditorCookie ec, Class<T> type, boolean redone) {
    UndoRedo ur;
    if (ec instanceof CloneableEditorSupport &&
            ((ur = ((CloneableEditorSupport)ec).getUndoRedo()) instanceof UndoRedoManager))
    {
        UndoRedoManager urManager = (UndoRedoManager) ur;
        UndoableEdit edit = urManager.editToBeUndoneRedone(redone);
        if (type.isInstance(edit)) {
            return type.cast(edit);
        } else if (edit instanceof List) {
            @SuppressWarnings("unchecked")
            List<UndoableEdit> listEdit = (List<UndoableEdit>) edit;
            for (int i = listEdit.size() -1; i >= 0; i--) { // Go from most wrapped back
                edit = listEdit.get(i);
                if (type.isInstance(edit)) {
                    @SuppressWarnings("unchecked") T inst = (T) edit;
                    return inst;
                }
            }
        }
    }
    return null;
}

@Override
public UndoableEdit wrap(UndoableEdit ed, Document doc) {
    if (!active.get()) {
        return ed;
    }
    if (doc.getProperty(BaseDocument.StreamDescriptionProperty) == null) {
        //no dataobject
        return ed;
    }
    UndoableEditDelegate current = new UndoableEditDelegate(ed, (BaseDocument) doc, performer);
    UndoableEditDelegate first = docToFirst.get(doc);
    if (first == null) {
        docToFirst.put((BaseDocument) doc, current);
    }
    return current;
}

@Override
   public boolean addEdit(UndoableEdit anEdit) {
if (!isInProgress()) {
    return false;
} else {
    UndoableEdit last = lastEdit();

    // If this is the first subedit received, just add it.
    // Otherwise, give the last one a chance to absorb the new
    // one.  If it won't, give the new one a chance to absorb
    // the last one.

    if (last == null) {
    edits.add(anEdit);
    }
    else if (!last.addEdit(anEdit)) {
    if (anEdit.replaceEdit(last)) {
        edits.remove(edits.size()-1);
    }
    edits.add(anEdit);
    }

    return true;
}
   }

@Override
   public String getUndoPresentationName() {
UndoableEdit last = lastEdit();
if (last != null) {
    return last.getUndoPresentationName();
} else {
           String name = getPresentationName();
           if (!"".equals(name)) {
               name = NbBundle.getMessage(ContentEdit.class, "AbstractUndoableEdit.undoText.param", name); // NOI18N
           } else {
               name = NbBundle.getMessage(ContentEdit.class, "AbstractUndoableEdit.undoText"); // NOI18N
           }

           return name;
}
   }

@Override
   public String getRedoPresentationName() {
UndoableEdit last = lastEdit();
if (last != null) {
    return last.getRedoPresentationName();
} else {
           String name = getPresentationName();
           if (!"".equals(name)) {
               name = NbBundle.getMessage(ContentEdit.class, "AbstractUndoableEdit.redoText.param", name); // NOI18N
           } else {
               name = NbBundle.getMessage(ContentEdit.class, "AbstractUndoableEdit.redoText"); // NOI18N
           }

           return name;
}
   }

@Override
public boolean addEdit(UndoableEdit edit) {
    if ((lastEdit() != null) && lastEdit().equals(edit)) {
        return false;
    } else {
        return super.addEdit(edit);
    }
}

private void addEdit(UndoableEdit edit) {
    if (compoundEdits.isEmpty()) {
        UndoableEditEvent editEvent = new UndoableEditEvent(getMainList(), edit);
        for (UndoableEditListener l : editListeners) {
            l.undoableEditHappened(editEvent);
        }
    } else {
        compoundEdits.peek().addEdit(edit);
    }
}

public static void main(String[] args) {
    final LinkedList<UndoableEdit> edits = new LinkedList<UndoableEdit>();
    UndoableEditListener editListener = new UndoableEditListener() {
        @Override
        public void undoableEditHappened(UndoableEditEvent e) {
            System.out.println(e.getEdit());
            edits.addFirst(e.getEdit());
        }
    };

    UndoableList<Integer> list = new UndoableList<Integer>(new LinkedList<Integer>());
    list.addUndoableEditListener(editListener);
    for (int i = 1; i < 10; i++) {
        list.add(2*i);
    }
    System.out.println(list);
    list.add(6, 13);
    System.out.println(list);
    list.set(3, 7);
    System.out.println(list);

    List<Integer> subList = list.subList(3, 6);
    System.out.println(subList);
    subList.set(0, 8);
    System.out.println(list);
    System.out.println(subList);
    subList.remove(1);

    System.out.println("----------------------------------");
    for (UndoableEdit edit : edits) {
        System.out.println("Undo " + edit);
        edit.undo();
        System.out.println(list);
    }
}

private void startNewEdit (JTextComponent component, UndoableEdit atomicEdit) {
    if (edit != null) {
        // finish the last edit
        edit.end();
    }
    edit = new MyCompoundEdit();
    edit.addEdit(atomicEdit);
    super.undoableEditHappened(new UndoableEditEvent(component, edit));
    lastOffset = component.getCaretPosition();
    lastLength = component.getDocument().getLength();
}

private static void duplicate(Node[] nodes, int dimension, int direction) {
    List<RADComponent> comps = FormUtils.getSelectedLayoutComponents(nodes);
    RADVisualContainer parent = (comps != null) ? getParent(comps) : null;
    if (parent != null) {
        FormModel formModel = parent.getFormModel();
        LayoutModel layoutModel = formModel.getLayoutModel();
        Object layoutUndoMark = layoutModel.getChangeMark();
        UndoableEdit layoutEdit = layoutModel.getUndoableEdit();
        boolean autoUndo = true; // in case of unexpected error, for robustness

        String[] sourceIds = new String[comps.size()];
        String[] targetIds = new String[comps.size()];
        int i = 0;
        MetaComponentCreator creator = formModel.getComponentCreator();
        try {
            for (RADComponent comp : comps) {
                RADComponent copiedComp = creator.copyComponent(comp, parent);
                if (copiedComp == null) {
                    return; // copy failed...
                }
                sourceIds[i] = comp.getId();
                targetIds[i] = copiedComp.getId();
                i++;
            }
            FormEditor.getFormDesigner(formModel).getLayoutDesigner()
                    .duplicateLayout(sourceIds, targetIds, dimension, direction);
            autoUndo = false;
        } finally {
            if (layoutUndoMark != null && !layoutUndoMark.equals(layoutModel.getChangeMark())) {
                formModel.addUndoableEdit(layoutEdit);
            }
            if (autoUndo) {
                formModel.forceUndoOfCompoundEdit();
            }
        }
    }
}

@Override
public void run() {
    if (wheelerBlocked) {
        wheelerBlocked = false;
        if (wheeler != null) {
            EventQueue.invokeLater(wheeler);
        }
        return;
    }
    wheeler = null;
    RADVisualComponent comp = getMouseWheelComponent(formDesigner, true);
    if (comp == component) {
        FormModel formModel = getFormModel();
        LayoutModel layoutModel = getLayoutModel();
        Object layoutUndoMark = layoutModel.getChangeMark();
        javax.swing.undo.UndoableEdit ue = layoutModel.getUndoableEdit();
        boolean autoUndo = true;
        try {
            mouseHint = formDesigner.getLayoutDesigner().mouseWheelMoved(coalesced, units);
            autoUndo = false;
            showToolTip(lastEvent);
        } finally {
            formModel.fireContainerLayoutChanged((RADVisualContainer)comp, null, null, null);
            if (!layoutUndoMark.equals(layoutModel.getChangeMark())) {
                formModel.addUndoableEdit(ue);
            }
            if (autoUndo) {
                formModel.forceUndoOfCompoundEdit();
            } else { // successfully applied
                wheelerBlocked = true; // don't allow next changes until the current one is built in the designer
                EventQueue.invokeLater(this);
            }
        }
    }
}

private void updateComponentLayer(final boolean fireChange) {
    if (formModel == null) { // the form can be closed just after opened, before this gets called (#70439)
        return;
    }
    if (getLayoutDesigner() == null) {
        return;
    }

    // Ensure that the components are laid out
    componentLayer.revalidate(); // Add componentLayer among components to validate
    RepaintManager.currentManager(componentLayer).validateInvalidComponents();

    LayoutModel layoutModel = formModel.getLayoutModel();
    // If after a change (FormModel has a compound edit started, i.e. it's not
    // just after form loaded) that was not primarily in layout, start undo
    // edit in LayoutModel as well: some changes can be done when updating to
    // actual visual state that was affected by changes elsewhere.
    UndoableEdit layoutUndoEdit = formModel.isCompoundEditInProgress()
                                  && !layoutModel.isUndoableEditInProgress()
            ? layoutModel.getUndoableEdit() : null;

    if (getLayoutDesigner().updateCurrentState() && fireChange) {
        formModel.fireFormChanged(true); // hack: to regenerate code once again
    }

    if (layoutModel.endUndoableEdit() && layoutUndoEdit != null) {
        formModel.addUndoableEdit(layoutUndoEdit);
    }

    updateResizabilityActions();
    componentLayer.repaint();
}

/**
 * Aligns selected components in the specified direction.
 *
 * @param closed determines if closed group should be created.
 * @param dimension dimension to align in.
 * @param alignment requested alignment.
 */
void align(boolean closed, int dimension, int alignment) {
    // Check that the action is enabled
    Action action = null;
    Iterator iter = getDesignerActions(true).iterator();
    while (iter.hasNext()) {
        Action candidate = (Action)iter.next();
        if (candidate instanceof AlignAction) {
            AlignAction alignCandidate = (AlignAction)candidate;
            if ((alignCandidate.getAlignment() == alignment) && (alignCandidate.getDimension() == dimension)) {
                action = alignCandidate;
                break;
            }
        }
    }
    if ((action == null) || (!action.isEnabled())) {
        return;
    }
    Collection selectedIds = selectedLayoutComponentIds();
    RADComponent parent = commonParent(selectedIds);
    LayoutModel layoutModel = formModel.getLayoutModel();
    Object layoutUndoMark = layoutModel.getChangeMark();
    javax.swing.undo.UndoableEdit ue = layoutModel.getUndoableEdit();
    boolean autoUndo = true;
    try {
        getLayoutDesigner().align(selectedIds, closed, dimension, alignment);
        autoUndo = false;
    } finally {
        formModel.fireContainerLayoutChanged((RADVisualContainer)parent, null, null, null);
        if (!layoutUndoMark.equals(layoutModel.getChangeMark())) {
            formModel.addUndoableEdit(ue);
        }
        if (autoUndo) {
            formModel.forceUndoOfCompoundEdit();
        }
    }
}

UndoableEdit startOnSaveTasks() {
    assert (atomicDepth > 0); // Should only be called under atomic lock
    // If there would be any pending edits
    // fire them so that they don't clash with on-save tasks in undo manager.
    // Pending edits could occur due to an outer atomic lock
    // around CES.saveDocument(). Anyway it would generally be an undesirable situation
    // due to possibly invalid lock order (doc's atomic lock would then precede on-save tasks' locks).
    checkAndFireAtomicEdits();
    ensureAtomicEditsInited();
    return atomicEdits;

}

public @Override boolean replaceEdit(UndoableEdit anEdit) {
    if (nonSignificant) { // Non-significant edit must be replacing
        previousEdit = anEdit;
        // Becomes significant
        nonSignificant = false;
        return true;
    }
    if (!undoMergeReset && mergeEditIndex >= 0) { // Only merge if this edit contains BaseDocumentEvent child item
        List<UndoableEdit> thisEdits = getEdits();
        BaseDocumentEvent thisMergeEdit = (BaseDocumentEvent) thisEdits.get(mergeEditIndex);
        if (anEdit instanceof BaseDocument.AtomicCompoundEdit) {
            BaseDocument.AtomicCompoundEdit anAtomicEdit
                    = (BaseDocument.AtomicCompoundEdit)anEdit;
            List<UndoableEdit> anAtomicEditChildren = anAtomicEdit.getEdits();
            for (int i = 0; i < anAtomicEditChildren.size(); i++) {
                UndoableEdit child = (UndoableEdit)anAtomicEditChildren.get(i);
                if (child instanceof BaseDocumentEvent && thisMergeEdit.canMerge((BaseDocumentEvent)child)) {
                    previousEdit = anEdit;
                    return true;
                }
            }
        } else if (anEdit instanceof BaseDocumentEvent) {
            BaseDocumentEvent evt = (BaseDocumentEvent)anEdit;

            if (thisMergeEdit.canMerge(evt)) {
                previousEdit = anEdit;
                return true;
            }
        }
    }
    return false;
}

private static void sendUndoableEdit(Document d, UndoableEdit ue) {
    if(d instanceof AbstractDocument) {
        UndoableEditListener[] uels = ((AbstractDocument)d).getUndoableEditListeners();
        UndoableEditEvent ev = new UndoableEditEvent(d, ue);
        for(UndoableEditListener uel : uels) {
            uel.undoableEditHappened(ev);
        }
    }
}

/**
 * Removes part of the content.
 *
 * @param where the starting position >= 0, where + nitems < length()
 * @param nitems the number of characters to remove >= 0
 * @return an UndoableEdit object for undoing
 * @exception BadLocationException if the specified position is invalid
 * @see AbstractDocument.Content#remove
 */
public UndoableEdit remove(int where, int nitems) throws BadLocationException {
    if (where + nitems >= length()) {
        throw new BadLocationException("Invalid remove", length() + 1);
    }
    String removedString = getString(where, nitems);
    UndoableEdit edit = new RemoveUndo(where, removedString);
    replace(where, nitems, empty, 0);
    return edit;

}

@Override
public boolean addEdit(UndoableEdit anEdit) {
    if (anEdit instanceof MyEdit && ((MyEdit)anEdit).ignore) {
        return true;
    }
    return false;
}

UndoableEdit removeUpdate(int removeOffset, int removeLength) {
    // The algorithm here is similar to the one in PlainDocument.removeUpdate().
    // Unfortunately in case exactly a line element (or multiple line elements)
    // the algorithm removes extra line that follows the end of removed area.
    // That could be improved but compatibility with PlainDocument would be lost.
    Edit edit = null;
    int removeEndOffset = removeOffset + removeLength;
    int line0 = getElementIndex(removeOffset);
    int line1 = getElementIndex(removeEndOffset);
    if (line0 != line1) {
        // at least one line was removed
        line1++; // will remove the line where remove ends as well
        Element[] removeElements = new Element[line1 - line0];
        copyElements(line0, line1, removeElements, 0);
        Element[] addElements = new Element[] {
            new LineElement(this,
                ((LineElement)removeElements[0]).getStartPosition(),
                ((LineElement)removeElements[removeElements.length - 1]).getEndPosition()
            )
        };

        replace(line0, removeElements.length, addElements);
        edit = new Edit(line0, removeElements, addElements);
    }
    // checkConsistency();
    return edit;
}

/**
 * Removes part of the content.
 *
 * @param where the starting position >= 0, where + nitems < length()
 * @param nitems the number of characters to remove >= 0
 * @return an UndoableEdit object for undoing
 * @exception BadLocationException if the specified position is invalid
 * @see AbstractDocument.Content#remove
 */
public UndoableEdit remove(int where, int nitems) throws BadLocationException {
    if (where + nitems >= length()) {
        throw new BadLocationException("Invalid remove", length() + 1);
    }
    String removedString = getString(where, nitems);
    UndoableEdit edit = new RemoveUndo(where, removedString);
    replace(where, nitems, empty, 0);
    return edit;

}

@Override
public UndoableEdit wrap(UndoableEdit edit, Document doc) {
    WrapCompoundEdit2 wrapEdit = new WrapCompoundEdit2();
    wrapEdit.addEdit(edit);
    wrapEdit.end();
    return wrapEdit;
}

private UndoableEditDelegate(UndoableEdit ed, DataObject dob, RefactoringSession session) {
    undoManager = UndoManager.getDefault();
    ces = dob.getLookup().lookup(CloneableEditorSupport.class);
    //this.delegate = ed;
    this.inner = new CompoundEdit();
    inner.addEdit(ed);
    delegate = ed;
    this.session = session;
}

@Override
public boolean addEdit(UndoableEdit ue) {
    if (ue instanceof List) {
        List<UndoableEdit> listEdit = (List<UndoableEdit>) ue;
        UndoableEdit topEdit = listEdit.get(listEdit.size() - 1);
        // Check that there's only original document's edit and the wrapping refactoring edit
        boolean refatoringEditOnly = listEdit.size() == 2;
        if (refatoringEditOnly && topEdit instanceof UndoableEditDelegate) {
            inner.addEdit(listEdit.get(0));
            return true;
    }
    return false;
}
    return false;
}

private ModElement addModElement(UndoableEdit compoundEdit, int startOffset, int endOffset) {
    ModElement modElement = new ModElement(this, startOffset, endOffset);
    lastModElementIndex = findModElementIndex(startOffset, true);
    AddModElementEdit edit = new AddModElementEdit(lastModElementIndex, modElement);
    edit.run();
    compoundEdit.addEdit(edit);
    return modElement;
}

@Override
public UndoableEdit insertString(int offset, String str) throws BadLocationException {
    checkOffsetInDoc(offset);
    UndoEdit edit = new UndoEdit(false, offset, str);
    insertEdit(edit);
    return edit;
}

/**
 * Removes part of the content.
 *
 * @param where the starting position >= 0, where + nitems < length()
 * @param nitems the number of characters to remove >= 0
 * @return an UndoableEdit object for undoing
 * @exception BadLocationException if the specified position is invalid
 * @see AbstractDocument.Content#remove
 */
public UndoableEdit remove(int where, int nitems) throws BadLocationException {
    if (where + nitems >= length()) {
        throw new BadLocationException("Invalid remove", length() + 1);
    }
    String removedString = getString(where, nitems);
    UndoableEdit edit = new RemoveUndo(where, removedString);
    replace(where, nitems, empty, 0);
    return edit;

}

protected UndoableEdit lastEdit() {
int count = edits.size();
if (count > 0)
    return edits.get(count-1);
else
    return null;
   }

@Override
public void undoableEditHappened(UndoableEditEvent e) {
    UndoableEdit edit = e.getEdit();
    if (edit instanceof AbstractDocument.DefaultDocumentEvent) {
        try {
            AbstractDocument.DefaultDocumentEvent event = (AbstractDocument.DefaultDocumentEvent) edit;
            int start = event.getOffset();
            int len = event.getLength();
            String text = "";
            if ("addition".equals(edit.getPresentationName())) {
                text = event.getDocument().getText(start, len);
            }
            boolean isNeedStart = false;
            if (current == null
                || lastEditName == null 
                || !lastEditName.equals(edit.getPresentationName())
                || text.contains("\n") && !"deletion".equals(edit.getPresentationName())
                || Math.abs(lastOffset - start) > 1) {
                isNeedStart = true;
            }

            while (pointer < edits.size() - 1) {
                edits.remove(edits.size() - 1);
                isNeedStart = true;
            }
            if (isNeedStart) {
                createCompoundEdit();
            }

            current.addEdit(edit);
            lastEditName = edit.getPresentationName();
            lastOffset = start;

        } catch (BadLocationException e1) {
            if (logger.isDebugEnabled()) {
              logger.debug(e1, e1);
            }
        }
    }
}

@Override
public boolean replaceEdit(UndoableEdit anEdit) {
    if (undoRedoManager.isAtSavepoint()) { // Prohibit replacing at savepoint
        return false;
    }
    WrapUndoEdit wrapEdit = (WrapUndoEdit) anEdit;
    boolean replaced = delegate.replaceEdit(wrapEdit.delegate);
    undoRedoManager.checkLogOp("WrapUndoEdit.replaceEdit=" + replaced, anEdit);
    if (replaced) {
        undoRedoManager.checkReplaceSavepointEdit(wrapEdit, this);
    }
    return replaced;
}

void sendUndoableEdit(Document d, UndoableEdit ue) {
    if(d instanceof AbstractDocument) {
        UndoableEditListener[] uels = ((AbstractDocument)d).getUndoableEditListeners();
        UndoableEditEvent ev = new UndoableEditEvent(d, ue);
        for(UndoableEditListener uel : uels) {
            uel.undoableEditHappened(ev);
        }
    }
}

private UndoableEditDelegate(UndoableEdit ed, BaseDocument doc, InstantRefactoringPerformer performer) {
    DataObject dob = (DataObject) doc.getProperty(BaseDocument.StreamDescriptionProperty);
    this.ces = dob.getLookup().lookup(CloneableEditorSupport.class);
    this.inner = new CompoundEdit();
    this.inner.addEdit(ed);
    this.delegate = ed;
    this.performer = performer;
}

@Override
public boolean addEdit(UndoableEdit ue) {
    if (ue instanceof List) {
        List<UndoableEdit> listEdit = (List<UndoableEdit>) ue;
        UndoableEdit topEdit = listEdit.get(listEdit.size() - 1);
        // Check that there's only original document's edit and the wrapping refactoring edit
        boolean refatoringEditOnly = listEdit.size() == 2;
        if (refatoringEditOnly && topEdit instanceof UndoableEditDelegate) {
            inner.addEdit(listEdit.get(0));
            return true;
        }
        return false;
    }
    return false;
}

private static void sendUndoableEdit(Document d, UndoableEdit ue) {
    if(d instanceof AbstractDocument) {
        UndoableEditListener[] uels = ((AbstractDocument)d).getUndoableEditListeners();
        UndoableEditEvent ev = new UndoableEditEvent(d, ue);
        for(UndoableEditListener uel : uels) {
            uel.undoableEditHappened(ev);
        }
    }
}