/** Create an undo/redo manager. * This manager is then attached to the document, and listens to * all changes made in it. * <P> * The default implementation uses improved <code>UndoRedo.Manager</code>, * with support for various extensions (including {@link #BEGIN_COMMIT_GROUP} * and {@link #END_COMMIT_GROUP}). It is not wise to override this * method without delegating to <code>super.createUndoRedoManager</code>. * * @return the undo/redo manager */ protected UndoRedo.Manager createUndoRedoManager() { return new UndoRedoManager(this); }
@Override public void redo() throws CannotRedoException { undoRedoManager.checkLogOp("WrapUndoEdit.redo", this); boolean savepoint = undoRedoManager.isAtSavepoint(); if (savepoint) { undoRedoManager.beforeRedoAtSavepoint(this); } boolean done = false; try { delegate.redo(); done = true; // This will only happen if delegate.redo() does not throw CannotRedoException undoRedoManager.afterRedoCheck(this); } finally { if (!done && savepoint) { undoRedoManager.delegateRedoFailedAtSavepoint(this); } } }
@Override public void undo() throws CannotUndoException { undoRedoManager.checkLogOp("WrapUndoEdit.undo", this); boolean savepoint = undoRedoManager.isAtSavepoint(); if (savepoint) { undoRedoManager.beforeUndoAtSavepoint(this); } boolean done = false; try { delegate.undo(); done = true; // This will only happen if delegate.undo() does not throw CannotUndoException undoRedoManager.afterUndoCheck(this); } finally { if (!done && savepoint) { undoRedoManager.delegateUndoFailedAtSavepoint(this); } } }
void notifyWrapEditDie(UndoableEdit edit) { if (edit == savepointEdit) { // Savepoint neighbour died => no longer a savepoint checkLogOp("notifyWrapEditDie-savepoint-die", edit); // NOI18N savepointEdit = null; clearSaveActionsEdit(); } }
void delegateRedoFailedAtSavepoint(WrapUndoEdit edit) { checkLogOp("delegateRedoFailedAtSavepoint", edit); // NOI18N redoSaveActions(); }
void beforeUndoAtSavepoint(WrapUndoEdit edit) { checkLogOp("beforeUndoAtSavepoint: undoSaveActions()", edit); // NOI18N undoSaveActions(); }
@Override public synchronized boolean addEdit(UndoableEdit edit) { if (!isInProgress()) { return false; } if (edit == BEGIN_COMMIT_GROUP) { beginUndoGroup(); return true; } else if (edit == END_COMMIT_GROUP) { endUndoGroup(); return true; } else if (edit == MARK_COMMIT_GROUP) { commitUndoGroup(); return true; } if (needsNestingCommit > 0) { commitUndoGroup(); } if (!awaitingOnSaveTasks && buildUndoGroup > 0) { if (undoGroup == null) { undoGroup = new CompoundEdit(); } return undoGroup.addEdit(edit); } return addEditImpl(edit); }
void afterRedoCheck(WrapUndoEdit edit) { if (isAtSavepoint()) { // Redoing edit right before savepoint. checkLogOp("afterRedoCheck-atSavepoint", edit); // NOI18N // saveActionsEdit already processed by checkSavepointBeforeUndo() beforeSavepoint = false; savepointEdit = edit; } else if (savepointEdit == edit) { // Redone to savepoint if (onSaveTasksEdit != null) { checkLogOp(" saveActionsEdit.redo()", onSaveTasksEdit); // NOI18N onSaveTasksEdit.redo(); } checkLogOp("afterRedoCheck-becomesSavepoint", edit); // NOI18N assert (beforeSavepoint) : "Expected to be before savepoint"; // NOI18N markSavepointAndUnmodified(); } }
@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; }
checkLogOp("addEdit-inSaveActions", edit); // NOI18N if (onSaveTasksEdit == null) { onSaveTasksEdit = new CompoundEdit(); if (isAtSavepoint()) { checkLogOp("addEdit-atSavepoint", wrapEdit); // NOI18N beforeSavepoint = false; savepointEdit = wrapEdit; clearSaveActionsEdit(); checkLogOp("addEdit", wrapEdit); // NOI18N
@Override public void die() { undoRedoManager.checkLogOp("WrapUndoEdit.die", this); delegate.die(); undoRedoManager.notifyWrapEditDie(this); }
void checkReplaceSavepointEdit(WrapUndoEdit origEdit, WrapUndoEdit newEdit) { if (savepointEdit == origEdit) { checkLogOp("checkReplaceSavepointEdit-replacedSavepointEdit", origEdit); // NOI18N savepointEdit = newEdit; } }
@Override public void undo() throws javax.swing.undo.CannotUndoException { final StyledDocument doc = support.getDocument(); if (doc == null) { throw new javax.swing.undo.CannotUndoException(); // NOI18N } new DocLockedRun(1, doc); checkCallNotifyUnmodified(); }
/** * Commit any accumulated <tt>UndoableEdit</tt>s as an atomic * <tt>undo</tt>/<tt>redo</tt> group. {@link CompoundEdit#end} * is invoked on the <tt>CompoundEdit</tt> and it is added as a single * <tt>UndoableEdit</tt> to this <tt>UndoManager</tt>. * <p> * If edits are currently being coalesced, a new undo group is started. * This has no effect if edits are not being coalesced, for example * <tt>beginUndoGroup</tt> has not been called. */ private void commitUndoGroup() { if(undoGroup == null) { return; } // undoGroup is being set to null, // needsNestingCommit has no meaning now needsNestingCommit = 0; undoGroup.end(); addEditImpl(undoGroup); undoGroup = null; }
void afterUndoCheck(WrapUndoEdit edit) { if (isAtSavepoint()) { // Undoing edit right before savepoint. checkLogOp("afterUndoCheck-atSavepoint", edit); // NOI18N // saveActionsEdit already processed by checkSavepointBeforeUndo() beforeSavepoint = true; savepointEdit = edit; } else if (savepointEdit == edit) { // Undone to savepoint if (onSaveTasksEdit != null) { checkLogOp(" saveActionsEdit.redo()", onSaveTasksEdit); // NOI18N onSaveTasksEdit.redo(); } checkLogOp("afterUndoCheck-becomesSavepoint-markUnmodified", edit); // NOI18N assert (!beforeSavepoint) : "Expected to be behind savepoint"; // NOI18N markSavepointAndUnmodified(); } }
void delegateUndoFailedAtSavepoint(WrapUndoEdit edit) { checkLogOp("delegateUndoFailedAtSavepoint", edit); // NOI18N redoSaveActions(); }
void beforeRedoAtSavepoint(WrapUndoEdit edit) { checkLogOp("beforeRedoAtSavepoint", edit); // NOI18N undoSaveActions(); }
private void clearSaveActionsEdit() { if (onSaveTasksEdit != null) { checkLogOp(" saveActionsEdit-die", onSaveTasksEdit); // NOI18N onSaveTasksEdit.die(); onSaveTasksEdit = null; } }
@Override public void redo() throws javax.swing.undo.CannotRedoException { final StyledDocument doc = support.getDocument(); if (doc == null) { throw new javax.swing.undo.CannotRedoException(); // NOI18N } new DocLockedRun(0, doc); checkCallNotifyUnmodified(); }
private void undoSaveActions() { if (onSaveTasksEdit != null) { checkLogOp(" saveActionsEdit.undo()", onSaveTasksEdit); // NOI18N onSaveTasksEdit.undo(); } }