262 lines · 7.6 KB · Java
RawDownload
/* * Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved. * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. * * This code is free software; you can redistribute it and/or modify it * under the terms of the GNU General Public License version 2 only, as * published by the Free Software Foundation.  Oracle designates this * particular file as subject to the "Classpath" exception as provided * by Oracle in the LICENSE file that accompanied this code. * * This code is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License * version 2 for more details (a copy is included in the LICENSE file that * accompanied this code). * * You should have received a copy of the GNU General Public License version * 2 along with this work; if not, write to the Free Software Foundation, * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. * * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA * or visit www.oracle.com if you need additional information or have any * questions. */package javax.swing.undo; import java.util.*; /** * A concrete subclass of AbstractUndoableEdit, used to assemble little * UndoableEdits into great big ones. * * @author Ray Ryan */public class CompoundEdit extends AbstractUndoableEdit {    /**     * True if this edit has never received <code>end</code>.     */    boolean inProgress;     /**     * The collection of <code>UndoableEdit</code>s     * undone/redone en masse by this <code>CompoundEdit</code>.     */    protected Vector<UndoableEdit> edits;     public CompoundEdit() {        super();        inProgress = true;        edits = new Vector<UndoableEdit>();    }     /**     * Sends <code>undo</code> to all contained     * <code>UndoableEdits</code> in the reverse of     * the order in which they were added.     */    public void undo() throws CannotUndoException {        super.undo();        int i = edits.size();        while (i-- > 0) {            UndoableEdit e = edits.elementAt(i);            e.undo();        }    }     /**     * Sends <code>redo</code> to all contained     * <code>UndoableEdit</code>s in the order in     * which they were added.     */    public void redo() throws CannotRedoException {        super.redo();        Enumeration cursor = edits.elements();        while (cursor.hasMoreElements()) {            ((UndoableEdit)cursor.nextElement()).redo();        }    }     /**     * Returns the last <code>UndoableEdit</code> in     * <code>edits</code>, or <code>null</code>     * if <code>edits</code> is empty.     */    protected UndoableEdit lastEdit() {        int count = edits.size();        if (count > 0)            return edits.elementAt(count-1);        else            return null;    }     /**     * Sends <code>die</code> to each subedit,     * in the reverse of the order that they were added.     */    public void die() {        int size = edits.size();        for (int i = size-1; i >= 0; i--)        {            UndoableEdit e = edits.elementAt(i);//          System.out.println("CompoundEdit(" + i + "): Discarding " +//                             e.getUndoPresentationName());            e.die();        }        super.die();    }     /**     * If this edit is <code>inProgress</code>,     * accepts <code>anEdit</code> and returns true.     *     * <p>The last edit added to this <code>CompoundEdit</code>     * is given a chance to <code>addEdit(anEdit)</code>.     * If it refuses (returns false), <code>anEdit</code> is     * given a chance to <code>replaceEdit</code> the last edit.     * If <code>anEdit</code> returns false here,     * it is added to <code>edits</code>.     *     * @param anEdit the edit to be added     * @return true if the edit is <code>inProgress</code>;     *  otherwise returns false     */    public boolean addEdit(UndoableEdit anEdit) {        if (!inProgress) {            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.addElement(anEdit);            }            else if (!last.addEdit(anEdit)) {                if (anEdit.replaceEdit(last)) {                    edits.removeElementAt(edits.size()-1);                }                edits.addElement(anEdit);            }             return true;        }    }     /**     * Sets <code>inProgress</code> to false.     *     * @see #canUndo     * @see #canRedo     */    public void end() {        inProgress = false;    }     /**     * Returns false if <code>isInProgress</code> or if super     * returns false.     *     * @see     #isInProgress     */    public boolean canUndo() {        return !isInProgress() && super.canUndo();    }     /**     * Returns false if <code>isInProgress</code> or if super     * returns false.     *     * @see     #isInProgress     */    public boolean canRedo() {        return !isInProgress() && super.canRedo();    }     /**     * Returns true if this edit is in progress--that is, it has not     * received end. This generally means that edits are still being     * added to it.     *     * @see     #end     */    public boolean isInProgress() {        return inProgress;    }     /**     * Returns true if any of the <code>UndoableEdit</code>s     * in <code>edits</code> do.     * Returns false if they all return false.     */    public boolean  isSignificant() {        Enumeration cursor = edits.elements();        while (cursor.hasMoreElements()) {            if (((UndoableEdit)cursor.nextElement()).isSignificant()) {                return true;            }        }        return false;    }     /**     * Returns <code>getPresentationName</code> from the     * last <code>UndoableEdit</code> added to     * <code>edits</code>. If <code>edits</code> is empty,     * calls super.     */    public String getPresentationName() {        UndoableEdit last = lastEdit();        if (last != null) {            return last.getPresentationName();        } else {            return super.getPresentationName();        }    }     /**     * Returns <code>getUndoPresentationName</code>     * from the last <code>UndoableEdit</code>     * added to <code>edits</code>.     * If <code>edits</code> is empty, calls super.     */    public String getUndoPresentationName() {        UndoableEdit last = lastEdit();        if (last != null) {            return last.getUndoPresentationName();        } else {            return super.getUndoPresentationName();        }    }     /**     * Returns <code>getRedoPresentationName</code>     * from the last <code>UndoableEdit</code>     * added to <code>edits</code>.     * If <code>edits</code> is empty, calls super.     */    public String getRedoPresentationName() {        UndoableEdit last = lastEdit();        if (last != null) {            return last.getRedoPresentationName();        } else {            return super.getRedoPresentationName();        }    }     /**     * Returns a string that displays and identifies this     * object's properties.     *     * @return a String representation of this object     */    public String toString()    {        return super.toString()            + " inProgress: " + inProgress            + " edits: " + edits;    }}