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

@Override
public void undo() throws CannotUndoException {
    super.undo();
    try {
        Set<QualName> deleted = new HashSet<>(this.newTexts.keySet());
        deleted.removeAll(this.oldTexts.keySet());
        doDeleteTexts(getResourceKind(), deleted);
        if (this.oldProps != null) {
            doPutProperties(this.oldProps);
        }
        doPutTexts(getResourceKind(), this.oldTexts);
    } catch (IOException exc) {
        throw new CannotUndoException();
    }
    notifyObservers(this);
}

public @Override void undo() throws CannotUndoException {
    atomicLockImpl ();
    try {
        TokenHierarchyControl<?> thcInactive = thcInactive();
        try {
            super.undo();
        } finally {
            if (thcInactive != null) {
                thcInactive.setActive(true);
            }
        }
    } finally {
        atomicUnlockImpl ();
    }

    if (previousEdit != null) {
        previousEdit.undo();
    }

}

/** Implements {@code UndoRedo}. Undo an edit. It finds a manager which next undo edit has the highest 
 * time stamp and makes undo on it.
 * @exception CannotUndoException if it fails
 */
@Override
public synchronized void undo () throws CannotUndoException {
    PropertiesEditorSupport.UndoRedoStampFlagManager chosenManager = (PropertiesEditorSupport.UndoRedoStampFlagManager)getNextUndo();

    if (chosenManager == null) {
        throw new CannotUndoException();
    } else {
        Object atomicFlag = chosenManager.getAtomicFlagOfEditToBeUndone();
        if (atomicFlag == null) {// not linked with other edits as one atomic action
            chosenManager.undo();
        } else { // atomic undo compound from more edits in underlying managers
            boolean undone;
            do { // the atomic action can consists from more undo edits from same manager
                undone = false;
                for (Iterator<Manager> it = managers.iterator(); it.hasNext(); ) {
                    PropertiesEditorSupport.UndoRedoStampFlagManager manager = (PropertiesEditorSupport.UndoRedoStampFlagManager)it.next();
                    if(atomicFlag.equals(manager.getAtomicFlagOfEditToBeUndone())) {
                        manager.undo();
                        undone = true;
                    }
                }
            } while(undone);
        }
    }
}

public void testBasicFailUndo0() throws Exception {
    StableCompoundEdit cEdit = new StableCompoundEdit();
    TestEdit e0 = new TestEdit(true);
    TestEdit e1 = new TestEdit();
    cEdit.addEdit(e0);
    cEdit.addEdit(e1);
    NbTestCase.assertFalse("Not ended yet", cEdit.canUndo());
    NbTestCase.assertFalse("Not ended yet", cEdit.canRedo());
    cEdit.end();
    NbTestCase.assertTrue("Expected undoable", cEdit.canUndo());
    NbTestCase.assertFalse("Expected non-redoable", cEdit.canRedo());

    try {
        cEdit.undo();
        fail("Was expecting CannotUndoException exception.");
    } catch (CannotUndoException ex) {
        // Expected
    }
    NbTestCase.assertTrue("Expected undoable", cEdit.canUndo());
    NbTestCase.assertFalse("Expected non-redoable", cEdit.canRedo());
    NbTestCase.assertTrue("Expected undoable", e0.canUndo());
    NbTestCase.assertFalse("Expected non-redoable", e0.canRedo());
    NbTestCase.assertTrue("Expected undoable", e1.canUndo());
    NbTestCase.assertFalse("Expected non-redoable", e1.canRedo());

}

public void testBasicFailUndo1() throws Exception {
    StableCompoundEdit cEdit = new StableCompoundEdit();
    TestEdit e0 = new TestEdit();
    TestEdit e1 = new TestEdit(true);
    cEdit.addEdit(e0);
    cEdit.addEdit(e1);
    NbTestCase.assertFalse("Not ended yet", cEdit.canUndo());
    NbTestCase.assertFalse("Not ended yet", cEdit.canRedo());
    cEdit.end();
    NbTestCase.assertTrue("Expected undoable", cEdit.canUndo());
    NbTestCase.assertFalse("Expected non-redoable", cEdit.canRedo());

    try {
        cEdit.undo();
        fail("Was expecting CannotUndoException exception.");
    } catch (CannotUndoException ex) {
        // Expected
    }
    NbTestCase.assertTrue("Expected undoable", cEdit.canUndo());
    NbTestCase.assertFalse("Expected non-redoable", cEdit.canRedo());
    NbTestCase.assertTrue("Expected undoable", e0.canUndo());
    NbTestCase.assertFalse("Expected non-redoable", e0.canRedo());
    NbTestCase.assertTrue("Expected undoable", e1.canUndo());
    NbTestCase.assertFalse("Expected non-redoable", e1.canRedo());

}

public static void undo(Context context, final int count) throws Exception {
    final Document doc = getDocument(context);
    final UndoManager undoManager = (UndoManager) doc.getProperty(UndoManager.class);
    logUndoRedoOp(context, "UNDO", count);
    invoke(context, new Runnable() {
        @Override
        public void run() {
            try {
                int cnt = count;
                while (undoManager.canUndo() && --cnt >= 0) {
                    undoManager.undo();
                }
            } catch (CannotUndoException e) {
                throw new IllegalStateException(e);
            }
        }
    });
    logPostUndoRedoOp(context, count);
}

@Override
public void undo() {
    if (!canUndo()) {
        throw new CannotUndoException();
    }

    MyCompoundEdit u = edits.get(pointer);
    u.undo();
    pointer--;

}

@Override
public void undo() throws CannotUndoException {
    super.undo();

    // --- Remove the added components --------------
    HashSet<NetworkComponent> netComps2Remove = new HashSet<NetworkComponent>();
    for (NetworkComponent networkComponentPasted : this.pastedNetworkModel.getNetworkComponents().values()) {
        String netCompID = networkComponentPasted.getId();
        NetworkComponent netCompRemove = this.graphController.getNetworkModel().getNetworkComponent(netCompID);
        netComps2Remove.add(netCompRemove);
        this.graphController.removeAgent(networkComponentPasted);
    }
    this.graphController.getNetworkModel().removeNetworkComponents(netComps2Remove);

    NetworkModelNotification  notification = new NetworkModelNotification(NetworkModelNotification.NETWORK_MODEL_Component_Removed);
    notification.setInfoObject(netComps2Remove);
    this.graphController.notifyObservers(notification);

}

@Override
public void undo() throws CannotUndoException {
    try {
        ignore = true;

        // take text from position - 1
        String planText = history.get(position - 1);
        // parse it
        PoshParser parser = new PoshParser(new StringReader(planText));
        PoshPlan plan = parser.parsePlan();
        // synchronize with the editor tree
        lapTree.synchronize(plan);

        if (position > 0) {
            --position;
        }
    } catch (ParseException ex) {
        throw new CannotUndoException();
    } finally {
        ignore = false;
        cs.fireChange();
    }
}

@Override
public void undo() throws CannotUndoException {
    super.undo();
    try {
        boolean layout = getType() == LAYOUT;
        if (!layout) {
            Set<QualName> deleted = getNames(this.newGraphs);
            deleted.removeAll(getNames(this.oldGraphs));
            doDeleteGraphs(getResourceKind(), deleted);
            if (this.oldProps != null) {
                doPutProperties(this.oldProps);
            }
        }
        doPutGraphs(getResourceKind(), this.oldGraphs, layout);
    } catch (IOException exc) {
        throw new CannotUndoException();
    }
    notifyObservers(this);
}

@Override
public void undo() throws CannotUndoException {
    super.undo();
    boolean b = scene.getUndoRedoEnabled();
    scene.setUndoRedoEnabled(false);
    scene.getModel().getViewChangedEvent().addListener(this);
    scene.getModel().setData(oldModel);
    scene.getModel().getViewChangedEvent().removeListener(this);

    SwingUtilities.invokeLater(new Runnable() {

        @Override
        public void run() {
            scene.setScrollPosition(oldScrollPosition);
        }
    });

    scene.setUndoRedoEnabled(b);
}

@Override
public void undo() throws CannotUndoException {
    super.undo();
    boolean b = scene.getUndoRedoEnabled();
    scene.setUndoRedoEnabled(false);
    scene.getModel().getViewChangedEvent().addListener(this);
    scene.getModel().setData(oldModel);
    scene.getModel().getViewChangedEvent().removeListener(this);

    SwingUtilities.invokeLater(new Runnable() {

        @Override
        public void run() {
            scene.setScrollPosition(oldScrollPosition);
        }
    });

    scene.setUndoRedoEnabled(b);
}

public void actionPerformed(ActionEvent e) {
    try {
        undo.undo();
    } catch (CannotUndoException ex) {
        System.out.println("Unable to undo: " + ex);
        ex.printStackTrace();
    }
    update();
    redoAction.update();
}

@Override
public void undo() throws CannotUndoException {
    if (edit != null) {
        edit.end();
    }
    super.undo();
    edit = null;
}

@Override
public void undo() throws CannotUndoException {
    synchronized(delegates) {
        for (CompoundUndoManager cm : delegates) {
            if(cm.hasFocus()) {
                cm.undo();
                return;
            }
        }
    }
}

private void undoAtomicEdits() {
    if (atomicEdits != null && atomicEdits.size() > 0) {
        atomicEdits.end();
        if (atomicEdits.canUndo()) {
            atomicEdits.undo();
        } else {
            LOG.log(Level.WARNING,
                    "Cannot UNDO: " + atomicEdits.toString() + // NOI18N
                    " Edits: " + atomicEdits.getEdits(),       // NOI18N
                    new CannotUndoException());
        }
        atomicEdits = null;
    }
}

public void undo() throws CannotUndoException {
    GuardedDocument gdoc = (GuardedDocument)getDocument();
    boolean origBreak = gdoc.breakGuarded;
    gdoc.breakGuarded = true;
    super.undo();
    if (!origBreak) {
        gdoc.breakGuarded = false;
    }
}

public @Override void undo() throws CannotUndoException {
    super.undo();

    if (debugUndo) {
        /*DEBUG*/System.err.println("UNDO-" + dump()); // NOI18N
    }
    undoOrRedo(-length, true);
}

public void actionPerformed(ActionEvent e) {
    try {
        undo.undo();
    } catch (CannotUndoException ex) {
        System.out.println("Unable to undo: " + ex);
        ex.printStackTrace();
    }
    update();
    redoAction.update();
}

@Override
public void undo() throws CannotUndoException {
    JTextComponent focusedComponent = EditorRegistry.focusedComponent();
    if (focusedComponent != null) {
        if (focusedComponent.getDocument() == ces.getDocument()) {
            //call global undo only for focused component
            undoManager.undo(session, ces.getDocument());
        }
    }
    //delegate.undo();
    inner.undo();
}

public void actionPerformed(ActionEvent e) {
    try {
        undo.undo();
    } catch (CannotUndoException ex) {
        System.out.println("Unable to undo: " + ex);
        ex.printStackTrace();
    }
    update();
    redoAction.update();
}

public void undo() throws CannotUndoException {
    assert (!undone) : "Already undone";
    if (undoFail) {
        undoFailedCount++;
        throw new CannotUndoException();
    }
    undone = true;
}

@Override public void undo() throws CannotUndoException {
    InstantRefactoringPerformer perf = performer.get();

    if (perf != null) {
        perf.release(true);
    }
}

@Override
            public void undo() throws CannotUndoException {
//                JTextComponent focusedComponent = EditorRegistry.focusedComponent();
//                if (focusedComponent != null) {
//                    if (focusedComponent.getDocument() == ces.getDocument()) {
//                        //call global undo only for focused component
//                        undoManager.undo(session);
//                    }
//                }
                //delegate.undo();
                inner.undo();
            }

@Override
public void undo() throws CannotUndoException {
    if (edit != null) {
        edit.end();
    }
    super.undo();
    edit = null;
}

public void undo() throws CannotUndoException {
    super.undo();
    try {
    insertString(offset, string);
    // Update the Positions that were in the range removed.
    if(posRefs != null) {
        updateUndoPositions(posRefs, offset, length);
        posRefs = null;
    }
    string = null;
    } catch (BadLocationException bl) {
      throw new CannotUndoException();
    }
}

/** Overrides superclass method. Updates time stamp for the edit. */
@Override
public synchronized void undo() throws CannotUndoException {
    UndoableEdit anEdit = editToBeUndone();
    if(anEdit != null) {
        Object atomicFlag = stampFlags.get(anEdit).getAtomicFlag(); // atomic flag remains
        super.undo();
        stampFlags.put(anEdit, new StampFlag(System.currentTimeMillis(), atomicFlag));
    }
}

@Override public void undo() throws CannotUndoException {
    InstantRenamePerformer perf = performer.get();

    if (perf != null) {
        perf.release();
    }
}

@Override
public void undo() throws CannotUndoException {
    boolean undoStartedTransaction = false;
    boolean needsRefresh = true;
    try {
        startTransaction(true, true); //start pseudo transaction for event firing
        undoStartedTransaction = true;
        AbstractModel.this.getAccess().prepareForUndoRedo();
        super.undo(); 
        AbstractModel.this.getAccess().finishUndoRedo();
        endTransaction();
        needsRefresh = false;
    } catch(CannotUndoException ex) {
        needsRefresh = false;
        throw ex;
    } finally {
        if (undoStartedTransaction && isIntransaction()) {
            try {
                endTransaction(true); // do not fire events
            } catch(Exception e) {
                Logger.getLogger(getClass().getName()).log(Level.INFO, "Undo error", e); //NOI18N
            }
        }
        if (needsRefresh) {
            setState(State.NOT_SYNCED); 
            refresh(); 
        }
    }
}

@Override
   public void undo() throws CannotUndoException {
if (!canUndo()) {
    throw new CannotUndoException();
}
statusBits &= ~HAS_BEEN_DONE; // hasBeenDone = false;
   }

@Override
public void redo() {
    if (!canRedo()) {
        throw new CannotUndoException();
    }

    pointer++;
    MyCompoundEdit u = edits.get(pointer);
    u.redo();

}

public void actionPerformed(ActionEvent e) {
    try {
        undo.undo();
    } catch (CannotUndoException ex) {
        System.out.println("Unable to undo: " + ex);
        ex.printStackTrace();
    }
    update();
    redoAction.update();
}

@Override
public void undo() throws CannotUndoException {
    super.undo();
    if (removal) {
        insertEdit(this);
    } else {
        removeEdit(this);
    }
}

@Override
public void undo() throws CannotUndoException {
    super.undo();
    if (mayDifferPairs != null) {
        for (PositionPair pair : mayDifferPairs) {
            assert (!pair.mayDiffer) : "Invalid pair: " + pair; // NOI18N
            pair.mayDiffer = true;
        }
    }
    assert (mayDifferUndoItem == this) : "Invalid mayDifferUndoItem=" + mayDifferUndoItem;
    mayDifferUndoItem = previousItem;
}

@Override
public void undo() throws CannotUndoException {
    if (fireException) {
        throw new CannotUndoException();
    }
    super.undo();
}

public void undo() throws CannotUndoException {
    super.undo();

    replace(index, childrenAdded.length, childrenRemoved);

    // Switch childrenAdded with childrenRemoved
    Element[] tmp = childrenRemoved;
    childrenRemoved = childrenAdded;
    childrenAdded = tmp;
}

@Override
public void undo() throws CannotUndoException {
    super.undo();
       try {
           model.resetDocument(oldDocument);
       } catch (RuntimeException ex) {
           if (oldDocument != model.getCurrentDocument()) {
               CannotUndoException e = new CannotUndoException();
               e.initCause(ex);
               throw e;
           } else {
               throw ex;
           }
       }
}

@Override
public void undo() throws CannotUndoException {
    if (undoFails) {
        throw new CannotUndoException();
    }
    undo++;
}

@Override
public void undo() throws CannotUndoException {
    super.undo();
    if (!inactive) {
        inactive = true;
        CodeTemplateInsertHandler handler = (CodeTemplateInsertHandler) doc.getProperty(CT_HANDLER_DOC_PROPERTY);
        if (handler != null) {
            handler.release();
        }
    }
}

@Override
public void undo() throws CannotUndoException {
    if(delegate != null) {
        delegate.undo();
    } else {
        UndoRedo.NONE.undo();
    }
}