Java UndoRedo类代码示例

import org.openide.awt.UndoRedo; //导入依赖的package包/类
public void testGetUndoRedo() throws Exception {
    final MVElem elem1 = new MVElem(new Action[] {new Act1("act1")} );
    UndoRedo redo = new UndoRedo.Empty();
    elem1.setUndoRedo(redo);
    final MVElem elem2 = new MVElem(new Action[] {new Act1("act2")} );
    MultiViewDescription desc1 = new MVDesc("desc1", null, 0, elem1);
    MultiViewDescription desc2 = new MVDesc("desc2", null, 0, elem2);
    MultiViewDescription[] descs = new MultiViewDescription[] { desc1, desc2 };
    TopComponent tc = callFactory(descs, desc2);
    
    tc.open();
    UndoRedo result = tc.getUndoRedo();
    MultiViewHandler hand = MultiViews.findMultiViewHandler(tc);
    
    assertNotNull(result);
    assertTrue(redo != result);
    
    hand.requestActive(Accessor.DEFAULT.createPerspective(desc1));
    result = tc.getUndoRedo();
    assertFalse(redo.canRedo());
    assertFalse(redo.canUndo());
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
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;
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
/**
     * Gets the undo redo manager.
     * @return the manager
     */
    protected final synchronized UndoRedo.Manager getUndoRedo() {
        CloneableEditorSupport redirect = CloneableEditorSupportRedirector.findRedirect(this);
        if (redirect != null) {
            return redirect.getUndoRedo();
        }
        
        if (undoRedo == null) {
            UndoRedo.Manager mgr = createUndoRedoManager();
//            if (!(mgr instanceof UndoRedoManager)) {
//                ERR.info("createUndoRedoManager(): ignoring created instance of class " + // NOI18N
//                        mgr.getClass() + " since CloneableEditorSupport requires instance of " + // NOI18N"
//                        UndoRedoManager.class.getName() + "\n"); // NOI18N
//                mgr = new UndoRedoManager(this);
//            }
            undoRedo = mgr;
        }

        return undoRedo;
    }
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
static void flushUndoQueue(Document d) {
    SwingUtilities.invokeLater(() -> {
    if (d == null) {
        return;
    }
    for (TopComponent tc : TopComponent.getRegistry().getOpened()) {
        if (!(tc instanceof ConsoleEditor)) {
            continue;
        }
        ConsoleEditor cake = (ConsoleEditor)tc;
        if (cake.getEditorPane() == null) {
            continue;
        }
        Document check = cake.getEditorPane().getDocument();
        if (check != d) {
            continue;
        }
        UndoRedo ur = tc.getUndoRedo();
        if (ur instanceof UndoManager) {
            ((UndoManager)ur).discardAllEdits();
        }
    }});
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
/** Gets manager which undo edit comes to play.*/
private UndoRedo getNextUndo() {
    UndoRedo chosenManager = null;
    long time = 0L; // time to compare with
    long timeManager; // time of next undo of actual manager
    
    for (Iterator<Manager> it = managers.iterator(); it.hasNext(); ) {
        PropertiesEditorSupport.UndoRedoStampFlagManager manager = (PropertiesEditorSupport.UndoRedoStampFlagManager)it.next();
        timeManager = manager.getTimeStampOfEditToBeUndone();
        if(timeManager > time) {
            time = timeManager;
            chosenManager = manager;
        }
    }
    return chosenManager;
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
/** Gets manager which redo edit comes to play.*/
private UndoRedo getNextRedo() {
    UndoRedo chosenManager = null;
    long time = 0L; // time to compare with
    long timeManager; // time of next redo of actual manager
    
    for (Iterator<Manager> it = managers.iterator(); it.hasNext(); ) {
        PropertiesEditorSupport.UndoRedoStampFlagManager manager = (PropertiesEditorSupport.UndoRedoStampFlagManager)it.next();
        timeManager = manager.getTimeStampOfEditToBeRedone();
        if(timeManager > time) {
            time = timeManager;
            chosenManager = manager;
        }
    }
    return chosenManager;
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
@Override
public void run() {
    if (!EventQueue.isDispatchThread()) {
        EventQueue.invokeLater(this);
        return;
    }

    UndoRedo ur = getUndoRedo();
    last.removeChangeListener(weakCL);

    if (doUndo) {
        setEnabled(ur.canUndo());
    } else {
        setEnabled(ur.canRedo());
    }
    putValue(NAME, getName());
    
    last = ur;
    last.addChangeListener(weakCL);
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
private UndoRedo getUndoRedo() {
    assert EventQueue.isDispatchThread();
    for (UndoRedo.Provider provider : result.allInstances()) {
        UndoRedo ur = provider.getUndoRedo();
        if (ur != null) {
            return ur;
        }
    }

    if (fallback) {
        TopComponent el = WindowManager.getDefault().getRegistry().getActivated();
        if (el != null) {
            UndoRedo ur = el.getUndoRedo();
            if (ur != null) {
                return ur;
            }
        }
    }
    return UndoRedo.NONE;
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
/** Update status of action.
*/
static synchronized void updateStatus() {
    if (undoAction == null) {
        undoAction = findObject (UndoAction.class, false);
    }

    if (redoAction == null) {
        redoAction = findObject (RedoAction.class, false);
    }

    SwingUtilities.invokeLater(
        new Runnable() {
            public void run() {
                UndoRedo ur = getUndoRedo();

                if (undoAction != null) {
                    undoAction.setEnabled(ur.canUndo());
                }

                if (redoAction != null) {
                    redoAction.setEnabled(ur.canRedo());
                }
            }
        }
    );
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
/** Creates <code>Runnable</code> which tries to make one undo. Helper method.
 * @see #revertUpcomingUndo */
private Runnable createUndoTask() {
    return new Runnable() {
        public void run() {
            StyledDocument sd = doc;
            if(sd == null) {
                // #20883, doc can be null(!), doCloseDocument was faster.
                return;
            }
            UndoRedo ur = getUndoRedo();
            sd.removeDocumentListener(getListener());
            try {
                if(ur.canUndo()) {
                    Toolkit.getDefaultToolkit().beep();
                    ur.undo();
                }
            } catch(CannotUndoException cne) {
                ErrorManager.getDefault().notify(
                    ErrorManager.INFORMATIONAL, cne);
            } finally {
                sd.addDocumentListener(getListener());
            }
        }
    };
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
public static VectorDataNode createDefaultVectorDataNode(Product product, String name, String description) {
    CoordinateReferenceSystem modelCrs = product.getSceneCRS();
    SimpleFeatureType type = PlainFeatureFactory.createDefaultFeatureType(modelCrs);
    VectorDataNode vectorDataNode = new VectorDataNode(name, type);
    vectorDataNode.setDescription(description);
    product.getVectorDataGroup().add(vectorDataNode);
    vectorDataNode.getPlacemarkGroup();
    String oldLayerId = selectVectorDataLayer(vectorDataNode);

    UndoRedo.Manager undoManager = SnapApp.getDefault().getUndoManager(product);
    if (undoManager != null) {
        undoManager.addEdit(new UndoableVectorDataNodeInsertion(product, vectorDataNode, oldLayerId));
    }

    return vectorDataNode;
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
void newPin() {
    Guardian.assertNotNull("product", product);
    String[] uniquePinNameAndLabel = PlacemarkNameFactory.createUniqueNameAndLabel(placemarkDescriptor, product);
    Placemark newPlacemark = Placemark.createPointPlacemark(placemarkDescriptor, uniquePinNameAndLabel[0],
                                                            uniquePinNameAndLabel[1],
                                                            "",
                                                            new PixelPos(0, 0), null,
                                                            product.getSceneGeoCoding());
    if (PlacemarkDialog.showEditPlacemarkDialog(
            SwingUtilities.getWindowAncestor(this), product, newPlacemark, placemarkDescriptor)) {
        makePlacemarkNameUnique(newPlacemark);
        UndoRedo.Manager undoManager = SnapApp.getDefault().getUndoManager(product);
        if (undoManager != null) {
            undoManager.addEdit(UndoablePlacemarkActionFactory.createUndoablePlacemarkInsertion(product, newPlacemark, placemarkDescriptor));
        }
        updateUIState();
    }
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
void copyActivePlacemark() {
    Guardian.assertNotNull("product", product);
    Placemark activePlacemark = getSelectedPlacemark();
    Guardian.assertNotNull("activePlacemark", activePlacemark);
    Placemark newPlacemark = Placemark.createPointPlacemark(activePlacemark.getDescriptor(),
                                                            "copy_of_" + activePlacemark.getName(),
                                                            activePlacemark.getLabel(),
                                                            activePlacemark.getDescription(),
                                                            activePlacemark.getPixelPos(),
                                                            activePlacemark.getGeoPos(),
                                                            activePlacemark.getProduct().getSceneGeoCoding());
    newPlacemark.setStyleCss(activePlacemark.getStyleCss());
    if (PlacemarkDialog.showEditPlacemarkDialog(
            SwingUtilities.getWindowAncestor(this), product, newPlacemark, placemarkDescriptor)) {
        makePlacemarkNameUnique(newPlacemark);
        UndoRedo.Manager undoManager = SnapApp.getDefault().getUndoManager(product);
        if (undoManager != null) {
            undoManager.addEdit(UndoablePlacemarkActionFactory.createUndoablePlacemarkCopying(product, newPlacemark, placemarkDescriptor));
        }
        updateUIState();
    }
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
void editActivePin() {
    Guardian.assertNotNull("product", product);
    Placemark activePlacemark = getSelectedPlacemark();
    Placemark originalPlacemark = Placemark.createPointPlacemark(activePlacemark.getDescriptor(),
                                                                 activePlacemark.getName(),
                                                                 activePlacemark.getLabel(),
                                                                 activePlacemark.getDescription(),
                                                                 activePlacemark.getPixelPos(),
                                                                 activePlacemark.getGeoPos(),
                                                                 activePlacemark.getProduct().getSceneGeoCoding());
    Guardian.assertNotNull("activePlacemark", activePlacemark);
    if (PlacemarkDialog.showEditPlacemarkDialog(SwingUtilities.getWindowAncestor(this), product, activePlacemark,
                                                placemarkDescriptor)) {
        makePlacemarkNameUnique(activePlacemark);
        UndoRedo.Manager undoManager = SnapApp.getDefault().getUndoManager(product);
        if (undoManager != null) {
            undoManager.addEdit(UndoablePlacemarkActionFactory.createUndoablePlacemarkEditing(product, originalPlacemark, activePlacemark, placemarkDescriptor));
        }
        updateUIState();
    }
}
 

import org.openide.awt.UndoRedo; //导入依赖的package包/类
void removeSelectedPins() {
    final List<Placemark> placemarks = getSelectedPlacemarks();
    for (Placemark placemark : placemarks) {
        getPlacemarkGroup(product).remove(placemark);
    }
    int selectedRow = placemarkTable.getSelectedRow();
    if (selectedRow >= getPlacemarkGroup(product).getNodeCount()) {
        selectedRow = getPlacemarkGroup(product).getNodeCount() - 1;
    }
    if (selectedRow >= 0) {
        placemarkTable.getSelectionModel().setSelectionInterval(selectedRow, selectedRow);
    }
    UndoRedo.Manager undoManager = SnapApp.getDefault().getUndoManager(product);
    if (undoManager != null) {
        undoManager.addEdit(UndoablePlacemarkActionFactory.createUndoablePlacemarkRemoval(product, placemarks, placemarkDescriptor));
    }
    updateUIState();
}