/*

 * 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

 */

@SuppressWarnings("serial") // Same-version serialization only

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<UndoableEdit> cursor = edits.elements();

        while (cursor.hasMoreElements()) {

            cursor.nextElement().redo();

        }

    }

    /**

     * Returns the last <code>UndoableEdit</code> in

     * <code>edits</code>, or <code>null</code>

     * if <code>edits</code> is empty.

     *

     * @return the last {@code UndoableEdit} in {@code edits},

     *         or {@code null} if {@code edits} 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.

     *

     * @return  whether this edit is in progress

     * @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<UndoableEdit> cursor = edits.elements();

        while (cursor.hasMoreElements()) {

            if (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;

    }

}