Java UndoRedo.Manager方法代码示例

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包/类
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 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();
}
 

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包/类
@Override
public UndoRedo getUndoRedo() {
    if (undoRedo == null) {
        undoRedo = new UndoRedo.Manager();
    }
    return undoRedo;
}
 

import org.openide.awt.UndoRedo; //导入方法依赖的package包/类
public UndoRedo.Manager getUndoRedoManager() {
//        if (undoRedoManager == null) {
//            undoRedoManager = new UndoRedoManager();
//            undoRedoManager.setLimit(50);
//        }
        return undoRedoManager;
    }
 

import org.openide.awt.UndoRedo; //导入方法依赖的package包/类
public void testUndoRedoEdits() throws Exception {
    Document doc = support.openDocument();
    doc.insertString(0, "a", null);
    UndoRedo.Manager ur = support.getUndoRedo();
    MyEdit myEdit = NbDocument.getEditToBeUndoneOfType(support, MyEdit.class);
    assertNotNull("Expected valid myEdit", myEdit);
    ur.undo();
    myEdit = NbDocument.getEditToBeRedoneOfType(support, MyEdit.class);
    assertNotNull("Expected valid myEdit", myEdit);
}
 

import org.openide.awt.UndoRedo; //导入方法依赖的package包/类
private UndoRedo.Manager getUndoRedo(EditorCookie cookie) {
    // TODO: working around #96543 
    try {
        Method method = CloneableEditorSupport.class.getDeclaredMethod("getUndoRedo"); // NOI18N
        method.setAccessible(true);
        return (UndoRedo.Manager) method.invoke(cookie);
    } catch (Exception e) {
        e.printStackTrace();
    }
    return null;
}
 

import org.openide.awt.UndoRedo; //导入方法依赖的package包/类
public void testUndoDeliversChangesWithTooManyEdits() {
    UndoRedo.Manager man = new UndoRedo.Manager() {
        @Override
        public boolean canUndo() {
            if (super.canUndo()) {
                undoableEditHappened(new UndoableEditEvent(UndoRedoActionTest.this, new MyEdit(true)));
            }
            return super.canUndo();
        }
    };
    doUndoRedoTest(man, false);
}
 

import org.openide.awt.UndoRedo; //导入方法依赖的package包/类
private void doUndoRedoTest(UndoRedo.Manager man, boolean testCounts) {
    me = new MyEdit();
    man.undoableEditHappened(new UndoableEditEvent(this, me));
    assertTrue("Can undo", man.canUndo());
    this.ur = man;
    
    InstanceContent ic = new InstanceContent();
    AbstractLookup lkp = new AbstractLookup(ic);
    Action u = undoAction(lkp);
    Action r = redoAction(lkp);

    assertFalse("Not enabled", u.isEnabled());
    assertFalse("Not enabledR", r.isEnabled());
    MyEdit lu = new MyEdit();
    MyEdit lr = new MyEdit();
    u.addPropertyChangeListener(lu);
    r.addPropertyChangeListener(lr);

    ic.add(this);

    assertTrue("Action is enabled", u.isEnabled());
    assertEquals("One change", 1, lu.cnt);
    assertEquals("No redo change", 0, lr.cnt);
    assertEquals("Undo presentation", "&Undo My Undo", u.getValue(Action.NAME));

    u.actionPerformed(new ActionEvent(this, 0, ""));
    if (testCounts) {
        assertEquals("my edit undone", 1, me.undo);

        assertFalse("No more undo", man.canUndo());
        assertTrue("But redo", man.canRedo());
        assertEquals("Another undo change", 2, lu.cnt);
        assertEquals("New redo change", 1, lr.cnt);
        assertTrue("Redo action enabled", r.isEnabled());
        assertEquals("Redo presentation correct", "&Redo My Redo", r.getValue(Action.NAME));
    }

    r.actionPerformed(new ActionEvent(this, 0, ""));
    assertFalse("Redo action no longer enabled", r.isEnabled());
}
 

import org.openide.awt.UndoRedo; //导入方法依赖的package包/类
private UndoRedo.Manager getUndoRedoManager() {
    if (undoRedoManager == null) {
        undoRedoManager = new UndoRedo.Manager();
        undoRedoManager.setLimit(UNDOREDO_LIMIT);
    }

    return undoRedoManager;
}
 

import org.openide.awt.UndoRedo; //导入方法依赖的package包/类
/**
 * Creates new form Map2DTopComponent
 */
public Map2DTopComponent() {
    super();
    initComponents();

    setIcon(ICON.getImage());
    this.setFocusable(true);
    undo = new UndoRedo.Manager();
    undo.setLimit(20); // limit to 20 rollback operations
}
 

import org.openide.awt.UndoRedo; //导入方法依赖的package包/类
public UndoRedo.Manager getUndoRedoManager()
{
    if (undoRedoManager == null)
    {
        undoRedoManager = new UndoRedoManager();
        undoRedoManager.setLimit(300);
    }
    return undoRedoManager;
}
 

import org.openide.awt.UndoRedo; //导入方法依赖的package包/类
public UndoRedo.Manager getUndoRedoManager()
{
    if (undoRedoManager == null)
    {
        undoRedoManager = new UndoRedoManager();           
        undoRedoManager.setLimit(300);     
    }
    return undoRedoManager;
}
 

import org.openide.awt.UndoRedo; //导入方法依赖的package包/类
public void addUndoableEdit(UndoableEdit edit, boolean aggregate)
{
    notifyReportChange();
    if (aggregate || forceAggregateUndo)
    {
        if (lastUndoableEdit != null &&
             lastUndoableEdit instanceof AggregatedUndoableEdit &&
             System.currentTimeMillis() - lastUndoableEditTime < 100)
         {
             ((AggregatedUndoableEdit)lastUndoableEdit).concatenate(edit);
             lastUndoableEditTime = System.currentTimeMillis();
             return;
         }
    }
    lastUndoableEditTime = System.currentTimeMillis();
    lastUndoableEdit = edit;
    if (getActiveVisualView() != null)
    {
        getActiveVisualView().getUndoRedoManager().undoableEditHappened(new UndoableEditEvent(this, edit));
    }
    else
    {
        // Check if the current lookup contains an undo manager...
        UndoRedo.Manager manager = Lookup.getDefault().lookup(UndoRedo.Manager.class);
        if (manager != null)
        {
            manager.undoableEditHappened(new UndoableEditEvent(this, edit));
        }
    }
}