Skip to content

R
riscv-gcc-1
Commit 45cfeb06 by Sascha Brawer Committed by Michael Koch
Options

UndoManager.java: Re-written from scratch. 

2004-02-14  Sascha Brawer  <brawer@dandelis.ch>

	* javax/swing/undo/UndoManager.java: Re-written from scratch.

From-SVN: r77827
parent 33421d69
Showing with 585 additions and 216 deletions
libjava/ChangeLog
2004-02-14 Sascha Brawer <brawer@dandelis.ch>
* javax/swing/undo/UndoManager.java: Re-written from scratch.
2004-02-14 Per Bothner <per@bothner.com> 2004-02-14 Per Bothner <per@bothner.com>
* java/nio/channels/spi/AbstractInterruptibleChannel.java (close): * java/nio/channels/spi/AbstractInterruptibleChannel.java (close):
......
libjava/javax/swing/undo/UndoManager.java
/* AbstractTableModel.java -- /* AbstractTableModel.java --
Copyright (C) 2002 Free Software Foundation, Inc. Copyright (C) 2002, 2004 Free Software Foundation, Inc.
This file is part of GNU Classpath. This file is part of GNU Classpath.
...@@ -38,223 +38,588 @@ exception statement from your version. */ ...@@ -38,223 +38,588 @@ exception statement from your version. */
package javax.swing.undo; package javax.swing.undo;
import javax.swing.UIManager;
import javax.swing.event.UndoableEditEvent; import javax.swing.event.UndoableEditEvent;
import javax.swing.event.UndoableEditListener; import javax.swing.event.UndoableEditListener;
/** /**
* UndoManager * A manager for providing an application&#x2019;s undo/redo
* @author Andrew Selkirk * functionality.
*
* <p>Tyipcally, an application will create only one single instance
* of UndoManager. When the user performs an undoable action, for
* instance changing the color of an object from green to blue, the
* application registers an {@link UndoableEdit} object with the
* <code>UndoManager</code>. To implement the &#x201c;undo&#x201d; and
* &#x201c;redo&#x201d; menu commands, the application invokes the
* UndoManager&#x2019;s {@link #undo} and {@link #redo} methods. The
* human-readable text of these menu commands is provided by {@link
* #getUndoPresentationName} and {@link #getRedoPresentationName},
* respectively. To determine whether the menu item should be
* selectable or greyed out, use {@link #canUndo} and {@link
* #canRedo}.
*
* <p>The UndoManager will only keep a specified number of editing
* actions, the <em>limit</em>. The value of this parameter can be
* retrieved by calling {@link #getLimit} and set with {@link
* #setLimit}. If more UndoableEdits are added to the UndoManager,
* the oldest actions will be discarded.
*
* <p>Some applications do not provide separate menu commands for
* &#x201c;undo&#x201d; and &#x201c;redo.&#x201d; Instead, they
* have just a single command whose text switches between the two.
* Such applications would use an UndoManager with a <code>limit</code>
* of 1. The text of this combined menu item is available via
* {@link #getUndoOrRedoPresentationName}, and it is implemented
* by calling {@link #undoOrRedo}.
*
* <p><b>Thread Safety:</b> In constrast to the other classes of the
* <code>javax.swing.undo</code> package, the public methods of an
* <code>UndoManager</code> are safe to call from concurrent threads.
* The caller does not need to perform external synchronization, and
* {@link javax.swing.event.UndoableEvent} sources do not need to
* broadcast their events from inside the Swing worker thread.
*
* @author <a href="mailto:brawer@dandelis.ch">Sascha Brawer</a>
*/ */
public class UndoManager extends CompoundEdit implements UndoableEditListener { public class UndoManager
extends CompoundEdit
//------------------------------------------------------------- implements UndoableEditListener
// Variables -------------------------------------------------- {
//------------------------------------------------------------- /**
* The unique ID for serializing instances of this class. Determined
/** * using the <code>serialver</code> tool of Sun JDK 1.4.1_01 on
* indexOfNextAdd * GNU/Linux.
*/ */
int indexOfNextAdd; static final long serialVersionUID = -2077529998244066750L;
/**
* limit /**
*/ * An index into the inherited {@link #edits} Vector that indicates
int limit; * at which position newly added editing actions would get inserted.
*
* <p>Normally, the value of <code>indexOfNextAdd</code> equals
//------------------------------------------------------------- * the number of UndoableEdits stored by this UndoManager, i.e.
// Initialization --------------------------------------------- * <code>edits.size()</code>. For each call to {@link #undo},
//------------------------------------------------------------- * <code>indexOfNextAdd</code> is decremented by one. For each
* call to {@link #redo}, it is incremented again.
/** */
* Constructor UndoManager int indexOfNextAdd;
*/
public UndoManager() {
// TODO /**
} // UndoManager() * The maximum number of UndoableEdits stored by this UndoManager.
*/
int limit;
//-------------------------------------------------------------
// Methods ----------------------------------------------------
//------------------------------------------------------------- /**
* Constructs an UndoManager.
/** *
* toString * <p>The <code>limit</code> of the freshly constructed UndoManager
* @returns String * is 100.
*/ */
public String toString() { public UndoManager()
return null; // TODO {
} // toString() limit = 100;
}
/**
* end
*/ /**
public synchronized void end() { * Returns a string representation for this UndoManager. This may be
// TODO * useful for debugging purposes. For the text of menu items, please
} // end() * refer to {@link #getUndoPresentationName}, {@link
* #getRedoPresentationName}, and {@link
/** * #getUndoOrRedoPresentationName}.
* getLimit */
* @returns int public String toString()
*/ {
public synchronized int getLimit() { return super.toString()
return 0; // TODO + " limit: " + limit
} // getLimit() + " indexOfNextAdd: " + indexOfNextAdd;
}
/**
* discardAllEdits
*/ /**
public synchronized void discardAllEdits() { * Puts this UndoManager into a state where it acts as a normal
// TODO * {@link CompoundEdit}. It is unlikely that an application would
} // discardAllEdits() * want to do this.
*/
/** public synchronized void end()
* trimForLimit {
*/ super.end();
protected void trimForLimit() { trimEdits(indexOfNextAdd, edits.size() - 1);
// TODO }
} // trimForLimit()
/** /**
* trimEdits * Returns how many edits this UndoManager can maximally hold.
* @param value0 TODO *
* @param value1 TODO * @see #setLimit
*/ */
protected void trimEdits(int value0, int value1) { public synchronized int getLimit()
// TODO {
} // trimEdits() return limit;
}
/**
* setLimit
* @param value0 TODO /**
*/ * Changes the maximal number of edits that this UndoManager can
public synchronized void setLimit(int value0) { * process. If there are currently more edits than the new limit
// TODO * allows, they will receive a {@link UndoableEdit#die() die}
} // setLimit() * message in reverse order of addition.
*
/** * @param limit the new limit.
* editToBeUndone *
* @returns UndoableEdit * @throws IllegalStateException if {@link #end()} has already been
*/ * called on this UndoManager.
protected UndoableEdit editToBeUndone() { */
return null; // TODO public synchronized void setLimit(int limit)
} // editToBeUndone() {
if (!isInProgress())
/** throw new IllegalStateException();
* editToBeRedone
* @returns UndoableEdit this.limit = limit;
*/ trimForLimit();
protected UndoableEdit editToBeRedone() { }
return null; // TODO
} // editToBeRedone()
/**
/** * Discards all editing actions that are currently registered with
* undoTo * this UndoManager. Each {@link UndoableEdit} will receive a {@link
* @param value0 TODO * UndoableEdit#die() die message}.
* @exception CannotUndoException TODO */
*/ public synchronized void discardAllEdits()
protected void undoTo(UndoableEdit value0) throws CannotUndoException { {
// TODO int size;
} // undoTo()
size = edits.size();
/** for (int i = size - 1; i >= 0; i--)
* redoTo ((UndoableEdit) edits.get(i)).die();
* @param value0 TODO indexOfNextAdd = 0;
* @exception CannotRedoException TODO edits.clear();
*/ }
protected void redoTo(UndoableEdit value0) throws CannotRedoException {
// TODO
} // redoTo() /**
* Called by various internal methods in order to enforce
/** * the <code>limit</code> value.
* undoOrRedo */
* @exception CannotRedoException TODO protected void trimForLimit()
* @exception CannotUndoException TODO {
*/ int high, s;
public synchronized void undoOrRedo() throws CannotRedoException, CannotUndoException {
// TODO s = edits.size();
} // undoOrRedo()
/* The Sun J2SE1.4.1_01 implementation can be observed to do
/** * nothing (instead of throwing an exception) with a negative or
* canUndoOrRedo * zero limit. It may be debatable whether this is the best
* @returns boolean * behavior, but we replicate it for sake of compatibility.
*/ */
public synchronized boolean canUndoOrRedo() { if (limit <= 0 || s <= limit)
return false; // TODO return;
} // canUndoOrRedo()
high = Math.min(indexOfNextAdd + limit/2 - 1, s - 1);
/** trimEdits(high + 1, s - 1);
* undo trimEdits(0, high - limit);
* @exception CannotUndoException TODO }
*/
public synchronized void undo() throws CannotUndoException {
// TODO /**
} // undo() * Discards a range of edits. All edits in the range <code>[from
* .. to]</code> will receive a {@linkplain UndoableEdit#die() die
/** * message} before being removed from the edits array. If
* canUndo * <code>from</code> is greater than <code>to</code>, nothing
* @returns boolean * happens.
*/ *
public synchronized boolean canUndo() { * @param from the lower bound of the range of edits to be
return false; // TODO * discarded.
} // canUndo() *
* @param to the upper bound of the range of edits to be discarded.
/** */
* redo protected void trimEdits(int from, int to)
* @exception CannotRedoException TODO {
*/ if (from > to)
public synchronized void redo() throws CannotRedoException { return;
// TODO
} // redo() for (int i = to; i >= from; i--)
((UndoableEdit) edits.get(i)).die();
/**
* canRedo // Remove the range [from .. to] from edits. If from == to, which
* @returns boolean // is likely to be a very common case, we can do better than
*/ // creating a sub-list and clearing it.
public synchronized boolean canRedo() { if (to == from)
return false; // TODO edits.remove(from);
} // canRedo() else
edits.subList(from, to + 1).clear();
/**
* addEdit if (indexOfNextAdd > to)
* @param value0 TODO indexOfNextAdd = indexOfNextAdd - to + from - 1;
* @returns boolean else if (indexOfNextAdd >= from)
*/ indexOfNextAdd = from;
public synchronized boolean addEdit(UndoableEdit value0) { }
return false; // TODO
} // addEdit()
/**
/** * Determines which significant edit would be undone if {@link
* getUndoOrRedoPresentationName * #undo()} was called.
* @returns String *
*/ * @returns the significant edit that would be undone, or
public synchronized String getUndoOrRedoPresentationName() { * <code>null</code> if no significant edit would be affected by
return null; // TODO * calling {@link #undo()}.
} // getUndoOrRedoPresentationName() */
protected UndoableEdit editToBeUndone()
/** {
* getUndoPresentationName UndoableEdit result;
* @returns String
*/ for (int i = indexOfNextAdd - 1; i >= 0; i--)
public synchronized String getUndoPresentationName() { {
return null; // TODO result = (UndoableEdit) edits.get(i);
} // getUndoPresentationName() if (result.isSignificant())
return result;
/** }
* getRedoPresentationName
* @returns String return null;
*/ }
public synchronized String getRedoPresentationName() {
return null; // TODO
} // getRedoPresentationName() /**
* Determines which significant edit would be redone if {@link
/** * #redo()} was called.
* undoableEditHappened *
* @param value0 TODO * @returns the significant edit that would be redone, or
*/ * <code>null</code> if no significant edit would be affected by
public void undoableEditHappened(UndoableEditEvent value0) { * calling {@link #redo()}.
// TODO */
} // undoableEditHappened() protected UndoableEdit editToBeRedone()
{
UndoableEdit result;
} // UndoManager
for (int i = indexOfNextAdd; i < edits.size(); i++)
{
result = (UndoableEdit) edits.get(i);
if (result.isSignificant())
return result;
}
return null;
}
/**
* Undoes all editing actions in reverse order of addition,
* up to the specified action,
*
* @param edit the last editing action to be undone.
*/
protected void undoTo(UndoableEdit edit)
throws CannotUndoException
{
UndoableEdit cur;
if (!edits.contains(edit))
throw new CannotUndoException();
while (true)
{
indexOfNextAdd -= 1;
cur = (UndoableEdit) edits.get(indexOfNextAdd);
cur.undo();
if (cur == edit)
return;
}
}
/**
* Redoes all editing actions in the same order as they were
* added to this UndoManager, up to the specified action.
*
* @param edit the last editing action to be redone.
*/
protected void redoTo(UndoableEdit edit)
throws CannotRedoException
{
UndoableEdit cur;
if (!edits.contains(edit))
throw new CannotRedoException();
while (true)
{
cur = (UndoableEdit) edits.get(indexOfNextAdd);
indexOfNextAdd += 1;
cur.redo();
if (cur == edit)
return;
}
}
/**
* Undoes or redoes the last action. If the last action has already
* been undone, it will be re-done, and vice versa.
*
* <p>This is useful for applications that do not present a separate
* undo and redo facility, but just have a single menu item for
* undoing and redoing the very last action. Such applications will
* use an <code>UndoManager</code> whose <code>limit</code> is 1.
*/
public synchronized void undoOrRedo()
throws CannotRedoException, CannotUndoException
{
if (indexOfNextAdd == edits.size())
undo();
else
redo();
}
/**
* Determines whether it would be possible to either undo or redo
* this editing action.
*
* <p>This is useful for applications that do not present a separate
* undo and redo facility, but just have a single menu item for
* undoing and redoing the very last action. Such applications will
* use an <code>UndoManager</code> whose <code>limit</code> is 1.
*
* @return <code>true</code> to indicate that this action can be
* undone or redone; <code>false</code> if neither is possible at
* the current time.
*/
public synchronized boolean canUndoOrRedo()
{
return indexOfNextAdd == edits.size() ? canUndo() : canRedo();
}
/**
* Undoes one significant edit action. If insignificant actions have
* been posted after the last signficant action, the insignificant
* ones will be undone first.
*
* <p>However, if {@link #end()} has been called on this
* UndoManager, it will behave like a normal {@link
* CompoundEdit}. In this case, all actions will be undone in
* reverse order of addition. Typical applications will never call
* {@link #end()} on their <code>UndoManager</code>.
*
* @throws CannotUndoException if no action can be undone.
*
* @see #canUndo()
* @see #redo()
* @see #undoOrRedo()
*/
public synchronized void undo()
throws CannotUndoException
{
if (!isInProgress())
{
super.undo();
return;
}
UndoableEdit edit = editToBeUndone();
if (edit == null)
throw new CannotUndoException();
undoTo(edit);
}
/**
* Determines whether it would be possible to undo this editing
* action.
*
* @return <code>true</code> to indicate that this action can be
* undone; <code>false</code> otherwise.
*
* @see #undo()
* @see #canRedo()
* @see #canUndoOrRedo()
*/
public synchronized boolean canUndo()
{
UndoableEdit edit;
if (!isInProgress())
return super.canUndo();
edit = editToBeUndone();
return edit != null && edit.canUndo();
}
/**
* Redoes one significant edit action. If insignificant actions have
* been posted in between, the insignificant ones will be redone
* first.
*
* <p>However, if {@link #end()} has been called on this
* UndoManager, it will behave like a normal {@link
* CompoundEdit}. In this case, <em>all</em> actions will be redone
* in order of addition. Typical applications will never call {@link
* #end()} on their <code>UndoManager</code>.
*
* @throws CannotRedoException if no action can be redone.
*
* @see #canRedo()
* @see #redo()
* @see #undoOrRedo()
*/
public synchronized void redo()
throws CannotRedoException
{
if (!isInProgress())
{
super.redo();
return;
}
UndoableEdit edit = editToBeRedone();
if (edit == null)
throw new CannotRedoException();
redoTo(edit);
}
/**
* Determines whether it would be possible to redo this editing
* action.
*
* @return <code>true</code> to indicate that this action can be
* redone; <code>false</code> otherwise.
*
* @see #redo()
* @see #canUndo()
* @see #canUndoOrRedo()
*/
public synchronized boolean canRedo()
{
UndoableEdit edit;
if (!isInProgress())
return super.canRedo();
edit = editToBeRedone();
return edit != null && edit.canRedo();
}
/**
* Registers an undoable editing action with this UndoManager. If
* the capacity <code>limit</code> is reached, the oldest action
* will be discarded (and receives a {@linkplain UndoableEdit#die()
* die message}. Equally, any actions that were undone (but not re-done)
* will be discarded, too.
*
* @param edit the editing action that is added to this UndoManager.
*
* @return <code>true</code> if <code>edit</code> could be
* incorporated; <code>false</code> if <code>edit</code> has not
* been incorporated because {@link #end()} has already been called
* on this <code>UndoManager</code>.
*/
public synchronized boolean addEdit(UndoableEdit edit)
{
boolean result;
// Discard any edits starting at indexOfNextAdd.
trimEdits(indexOfNextAdd, edits.size() - 1);
result = super.addEdit(edit);
indexOfNextAdd = edits.size();
trimForLimit();
return result;
}
/**
* Calculates a localized text for presenting the undo or redo
* action to the user, for example in the form of a menu command.
*
* <p>This is useful for applications that do not present a separate
* undo and redo facility, but just have a single menu item for
* undoing and redoing the very last action. Such applications will
* use an <code>UndoManager</code> whose <code>limit</code> is 1.
*
* @return the redo presentation name if the last action has already
* been undone, or the undo presentation name otherwise.
*
* @see #getUndoPresentationName()
* @see #getRedoPresentationName()
*/
public synchronized String getUndoOrRedoPresentationName()
{
if (indexOfNextAdd == edits.size())
return getUndoPresentationName();
else
return getRedoPresentationName();
}
/**
* Calculates a localized text for presenting the undo action
* to the user, for example in the form of a menu command.
*/
public synchronized String getUndoPresentationName()
{
UndoableEdit edit;
if (!isInProgress())
return super.getUndoPresentationName();
edit = editToBeUndone();
if (edit == null)
return UIManager.getString("AbstractUndoableEdit.undoText");
else
return edit.getUndoPresentationName();
}
/**
* Calculates a localized text for presenting the redo action
* to the user, for example in the form of a menu command.
*/
public synchronized String getRedoPresentationName()
{
UndoableEdit edit;
if (!isInProgress())
return super.getRedoPresentationName();
edit = editToBeRedone();
if (edit == null)
return UIManager.getString("AbstractUndoableEdit.redoText");
else
return edit.getRedoPresentationName();
}
/**
* Registers the edit action of an {@link UndoableEditEvent}
* with this UndoManager.
*
* <p><b>Thread Safety:</b> This method may safely be invoked from
* concurrent threads. The caller does not need to perform external
* synchronization. This means that {@link
* javax.swing.event.UndoableEvent} sources do not need to broadcast
* their events from inside the Swing worker thread.
*
* @param event the event whose <code>edit</code> will be
* passed to {@link #addEdit}.
*
* @see UndoableEditEvent#getEdit()
* @see #addEdit
*/
public void undoableEditHappened(UndoableEditEvent event)
{
// Note that this method does not need to be synchronized,
// because addEdit will obtain and release the mutex.
addEdit(event.getEdit());
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment