| /****************************************************************************** |
| * Copyright (c) 2002, 2009 IBM Corporation and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v1.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v10.html |
| * |
| * Contributors: |
| * IBM Corporation - initial API and implementation |
| * Nicolas Rouquette (NASA) - Fix for Bug 260812. |
| ****************************************************************************/ |
| |
| package org.eclipse.gmf.runtime.diagram.ui.parts; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.EventObject; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.core.commands.ExecutionException; |
| import org.eclipse.core.commands.operations.IOperationHistory; |
| import org.eclipse.core.commands.operations.IOperationHistoryListener; |
| import org.eclipse.core.commands.operations.IUndoContext; |
| import org.eclipse.core.commands.operations.IUndoableOperation; |
| import org.eclipse.core.commands.operations.ObjectUndoContext; |
| import org.eclipse.core.commands.operations.OperationHistoryEvent; |
| import org.eclipse.core.commands.operations.OperationHistoryFactory; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.gef.commands.Command; |
| import org.eclipse.gef.commands.CommandStack; |
| import org.eclipse.gef.commands.CommandStackListener; |
| import org.eclipse.gef.commands.CompoundCommand; |
| import org.eclipse.gmf.runtime.common.core.command.CommandResult; |
| import org.eclipse.gmf.runtime.common.core.command.CompositeCommand; |
| import org.eclipse.gmf.runtime.common.core.command.ICommand; |
| import org.eclipse.gmf.runtime.common.core.command.ICompositeCommand; |
| import org.eclipse.gmf.runtime.common.core.util.Log; |
| import org.eclipse.gmf.runtime.common.core.util.Trace; |
| import org.eclipse.gmf.runtime.diagram.ui.commands.CommandProxy; |
| import org.eclipse.gmf.runtime.diagram.ui.commands.ICommandProxy; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIDebugOptions; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIPlugin; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.DiagramUIStatusCodes; |
| import org.eclipse.gmf.runtime.diagram.ui.internal.tools.ConnectionHandleTool; |
| |
| /** |
| * GEF command stack that delegates to an {@link IOperationHistory}. |
| * |
| * @author sshaw |
| * @author Tauseef A, Israr |
| * @author ldamus |
| */ |
| public class DiagramCommandStack |
| extends CommandStack { |
| |
| private Map stackToManager = new HashMap(); |
| |
| private IDiagramEditDomain editDomain; |
| |
| private Command cmdRecent = null; |
| |
| private IOperationHistory delegate; |
| |
| private IUndoContext undoContext; |
| |
| private final class HistoryEventObject |
| extends EventObject { |
| |
| private final OperationHistoryEvent event; |
| |
| private HistoryEventObject(OperationHistoryEvent event) { |
| super(event.getHistory()); |
| this.event = event; |
| } |
| |
| /** |
| * Gets my operation history event. |
| * |
| * @return my operation history event. |
| */ |
| public OperationHistoryEvent getOperationHistoryEvent() { |
| return event; |
| } |
| } |
| |
| /** |
| * Initializes me with my diagram edit domain and undo context. |
| * |
| * @param editDomain |
| * the editing domain assoicated with this stack |
| * @param undoContext |
| * my undo context |
| */ |
| public DiagramCommandStack(IDiagramEditDomain editDomain) { |
| this.editDomain = editDomain; |
| } |
| |
| /** |
| * Adds a listener to this CommandStack. |
| * |
| * @param listener |
| * The Object listening to this CommandStack. |
| */ |
| public void addCommandStackListener(CommandStackListener listener) { |
| |
| final CommandStackListener csl = listener; |
| // The removal of the listener here is done to avoid multiple |
| // commandchangelisteners added to the commandmanager. |
| // Tauseef Israr |
| removeCommandStackListener(csl); |
| |
| IOperationHistoryListener cmcl = new IOperationHistoryListener() { |
| |
| public void historyNotification(OperationHistoryEvent event) { |
| if (csl != null) { |
| csl.commandStackChanged(new HistoryEventObject(event)); |
| } |
| } |
| }; |
| |
| stackToManager.put(csl, cmcl); |
| getOperationHistory().addOperationHistoryListener(cmcl); |
| } |
| |
| /** |
| * Returns <code>true</code> if there is a Command to redo. |
| * |
| * @return <code>true</code> if there is a Command to redo. |
| */ |
| public boolean canRedo() { |
| return getOperationHistory().canRedo(getUndoContext()); |
| } |
| |
| /** |
| * Returns <code>true</code> if the last Command executed can be undone. |
| * |
| * @return <code>true</code> if the last Command executed can be undone. |
| */ |
| public boolean canUndo() { |
| return getOperationHistory().canUndo(getUndoContext()); |
| } |
| |
| /** |
| * Executes the given Command if it can execute. |
| * |
| * @param command |
| * The Command to execute. |
| */ |
| public void execute(Command command) { |
| execute(command, null); |
| } |
| |
| /** |
| * Executes the given Command if it can execute. |
| * |
| * @param command |
| * The Command to execute. |
| * @param progressMonitor |
| */ |
| public void execute(Command command, IProgressMonitor progressMonitor) { |
| if (command == null || !command.canExecute()) |
| return; |
| execute(getICommand(command), progressMonitor); |
| } |
| |
| /** |
| * exectus a the supplied command |
| * |
| * @param command |
| * the command to execute |
| */ |
| protected void execute(ICommand command) { |
| execute(command, null); |
| } |
| |
| /** |
| * executes the supplied command |
| * |
| * @param command |
| * the command to exectue |
| * @param progressMonitor |
| */ |
| protected void execute(ICommand command, IProgressMonitor progressMonitor) { |
| |
| if (progressMonitor != null) { |
| try { |
| command.addContext(getUndoContext()); |
| getOperationHistory().execute(command, progressMonitor, null); |
| |
| } catch (ExecutionException e) { |
| Trace.catching(DiagramUIPlugin.getInstance(), |
| DiagramUIDebugOptions.EXCEPTIONS_CATCHING, |
| getClass(), "execute", e); //$NON-NLS-1$ |
| Log.error(DiagramUIPlugin.getInstance(), |
| DiagramUIStatusCodes.COMMAND_FAILURE, "execute", e); //$NON-NLS-1$ |
| } |
| } else { |
| try { |
| command.addContext(getUndoContext()); |
| getOperationHistory().execute(command, |
| new NullProgressMonitor(), null); |
| |
| } catch (ExecutionException e) { |
| Trace.catching(DiagramUIPlugin.getInstance(), |
| DiagramUIDebugOptions.EXCEPTIONS_CATCHING, |
| getClass(), "execute", e); //$NON-NLS-1$ |
| Log.error(DiagramUIPlugin.getInstance(), |
| DiagramUIStatusCodes.COMMAND_FAILURE, "execute", e); //$NON-NLS-1$ |
| } |
| } |
| |
| } |
| |
| |
| /** |
| * Converts a GEF {@link Command} into a GMF {@link ICommand} |
| * |
| * @param command |
| * the GEF command |
| * @return the GMF command |
| */ |
| public static ICommand getICommand(Command command) { |
| |
| if (command instanceof CompoundCommand) { |
| |
| CompositeCommand composite = new CompositeCommand( |
| command.getLabel()); |
| Object[] subCommands = ((CompoundCommand) command).getChildren(); |
| |
| for (int i = 0; i < subCommands.length; i++) { |
| composite.compose(getICommand((Command) subCommands[i])); |
| } |
| return composite.reduce(); |
| } |
| |
| if (command instanceof ICommandProxy) { |
| return getICommand(((ICommandProxy) command).getICommand()); |
| } |
| |
| if (null != command) { |
| return new CommandProxy(command); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Removes redundancies from <code>command</code> by stripping out layers |
| * of command wrappers used to accomodate the use of GEF commands on an |
| * {@link IOperationHistory} and {@link ICommand}s on the GEF |
| * {@link CommandStack}. |
| * |
| * @param command |
| * the command to be processed |
| * @return a command representing the simplified form of the input command. |
| * May be a new command. |
| */ |
| public static ICommand getICommand(ICommand command) { |
| |
| ICommand result = command; |
| |
| if (command instanceof ICompositeCommand) { |
| // process composite command |
| List processedCommands = new ArrayList(); |
| |
| ICompositeCommand composite = (ICompositeCommand) command; |
| |
| if (!composite.isEmpty()) { |
| |
| for (Iterator i = composite.iterator(); i.hasNext();) { |
| IUndoableOperation nextOperation = (IUndoableOperation) i |
| .next(); |
| |
| // remove the next child from the composite |
| i.remove(); |
| |
| // convert any GEF commands to GMF commands |
| if (nextOperation instanceof ICommand) { |
| ICommand nextCommand = (ICommand) nextOperation; |
| processedCommands.add(getICommand(nextCommand)); |
| |
| } else { |
| processedCommands.add(nextOperation); |
| } |
| } |
| |
| // add all the children back |
| for (Iterator i = processedCommands.iterator(); i.hasNext();) { |
| composite.add((IUndoableOperation) i.next()); |
| } |
| |
| // reduce to the simplest equivalent form |
| result = composite.reduce(); |
| } |
| |
| } else if (command instanceof CommandProxy) { |
| // process GEF command proxy |
| return getICommand(((CommandProxy) command).getCommand()); |
| } |
| |
| return result; |
| } |
| |
| /** |
| * Returns the most recently executed command. |
| * |
| * @return The most recently executed command. |
| */ |
| public Command getMostRecentCommand() { |
| return cmdRecent; |
| } |
| |
| /** |
| * getRedoCommand Returns the command at the top of the redo stack. |
| * |
| * @see org.eclipse.gef.commands.CommandStack#getRedoCommand() |
| */ |
| public Command getRedoCommand() { |
| if (getOperationHistory().canRedo(getUndoContext())) { |
| Command emptyCmd = new Command() { |
| // empty |
| }; |
| |
| IUndoableOperation redo = getOperationHistory().getRedoOperation( |
| getUndoContext()); |
| emptyCmd.setLabel(redo.getLabel()); |
| return emptyCmd; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * getUndoCommand() Returns the next command to be undone. |
| * |
| * @see org.eclipse.gef.commands.CommandStack#getUndoCommand() |
| */ |
| public Command getUndoCommand() { |
| if (getOperationHistory().canUndo(getUndoContext())) { |
| Command emptyCmd = new Command() { |
| // empty |
| }; |
| |
| IUndoableOperation undo = getOperationHistory().getUndoOperation( |
| getUndoContext()); |
| emptyCmd.setLabel(undo.getLabel()); |
| return emptyCmd; |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Executes the last undone Command. |
| */ |
| public void redo() { |
| cmdRecent = getRedoCommand(); |
| |
| try { |
| getOperationHistory().redo(getUndoContext(), |
| new NullProgressMonitor(), null); |
| |
| } catch (ExecutionException e) { |
| Trace.catching(DiagramUIPlugin.getInstance(), |
| DiagramUIDebugOptions.EXCEPTIONS_CATCHING, |
| ConnectionHandleTool.class, "redo", e); //$NON-NLS-1$ |
| Log.error(DiagramUIPlugin.getInstance(), |
| DiagramUIStatusCodes.COMMAND_FAILURE, "redo", e); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Removes the given CommandStackListener. |
| * |
| * @param listener |
| * The object to be removed from the list of listeners. |
| */ |
| public void removeCommandStackListener(CommandStackListener listener) { |
| final CommandStackListener csl = listener; |
| |
| if (csl != null) { |
| IOperationHistoryListener historyListener = (IOperationHistoryListener) stackToManager |
| .get(csl); |
| |
| if (historyListener != null) { |
| getOperationHistory().removeOperationHistoryListener( |
| historyListener); |
| } |
| // mgoyal: removing from stack manager |
| stackToManager.remove(csl); |
| } |
| } |
| |
| /** |
| * Undoes the last executed Command. |
| */ |
| public void undo() { |
| cmdRecent = getUndoCommand(); |
| |
| try { |
| getOperationHistory().undo(getUndoContext(), |
| new NullProgressMonitor(), null); |
| |
| } catch (ExecutionException e) { |
| Trace.catching(DiagramUIPlugin.getInstance(), |
| DiagramUIDebugOptions.EXCEPTIONS_CATCHING, |
| ConnectionHandleTool.class, "undo", e); //$NON-NLS-1$ |
| Log.error(DiagramUIPlugin.getInstance(), |
| DiagramUIStatusCodes.COMMAND_FAILURE, "undo", e); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Returns the editDomain. |
| * |
| * @return IDiagramEditDomain |
| */ |
| protected IDiagramEditDomain getDiagramEditDomain() { |
| return editDomain; |
| } |
| |
| /** |
| * Gets my operation history delegate. |
| * |
| * @return my operation history delegate |
| */ |
| protected IOperationHistory getOperationHistory() { |
| |
| if (delegate == null) { |
| delegate = OperationHistoryFactory.getOperationHistory(); |
| } |
| return delegate; |
| } |
| |
| /** |
| * Sets my operation history delegate. |
| * |
| * @param operationHistory |
| * my operation history delegate |
| */ |
| public void setOperationHistory(IOperationHistory operationHistory) { |
| this.delegate = operationHistory; |
| } |
| |
| /** |
| * Gets the return values of the given executed command |
| * |
| * @param c |
| * The command |
| * @return A collection of values returned by the given command |
| */ |
| public static Collection getReturnValues(Command c) { |
| if (c instanceof CompoundCommand) { |
| CompoundCommand cc = (CompoundCommand) c; |
| List l = new ArrayList(cc.size()); |
| for (Iterator i = cc.getCommands().iterator(); i.hasNext();) |
| l.addAll(getReturnValues((Command) i.next())); |
| return l; |
| |
| } else if (c instanceof ICommandProxy) { |
| return getReturnValues((ICommandProxy) c); |
| } |
| return Collections.EMPTY_LIST; |
| } |
| |
| /** |
| * gets the return the values for the supplied command. |
| * |
| * @param cmd |
| * command to use |
| * @return a collection of return values |
| */ |
| public static Collection getReturnValues(ICommandProxy cmd) { |
| return getReturnValues(cmd.getICommand()); |
| } |
| |
| |
| |
| |
| /** |
| * gets the return the values for the supplied command. |
| * @param cmd command to use |
| * @return a collection of return values |
| */ |
| public static Collection getReturnValues( CommandProxy cmd ) { |
| return getReturnValues( cmd.getCommand() ); |
| } |
| |
| /** |
| * gets the return the values for the supplied command. |
| * |
| * @param cmd |
| * command to use |
| * @return a collection of return values |
| */ |
| public static Collection getReturnValues(ICommand cmd) { |
| |
| if (cmd instanceof ICompositeCommand) { |
| ICompositeCommand cc = (ICompositeCommand) cmd; |
| List l = new ArrayList(); |
| for (Iterator i = cc.iterator(); i.hasNext();) { |
| IUndoableOperation child = (IUndoableOperation) i.next(); |
| if (child instanceof ICommand) { |
| l.addAll(getReturnValues((ICommand) child)); |
| } |
| } |
| return l; |
| |
| } else if ( cmd instanceof CommandProxy ) { // |
| // Need to recurse into the proxy command(s) since they |
| // will not have set the CommandProxy result |
| // This Could be moved into CommandProxy but |
| // #getCommandResult() can no longer be final. |
| return getReturnValues((CommandProxy)cmd); |
| |
| } else { |
| CommandResult r = cmd.getCommandResult(); |
| Object o = r != null ? r.getReturnValue() |
| : null; |
| |
| if (o instanceof Collection) { |
| return (Collection) o; |
| |
| } else if (o != null) { |
| return Collections.singletonList(o); |
| } |
| } |
| |
| return Collections.EMPTY_LIST; |
| } |
| |
| /** |
| * Gets my undo context. I add my context to all commands executed through |
| * me. |
| * |
| * @return my undo context |
| */ |
| public IUndoContext getUndoContext() { |
| |
| if (undoContext == null) { |
| undoContext = new ObjectUndoContext(this); |
| } |
| return undoContext; |
| } |
| |
| /** |
| * Sets my undo context. |
| * |
| * @param undoContext |
| * my undo context |
| */ |
| public void setUndoContext(IUndoContext undoContext) { |
| this.undoContext = undoContext; |
| } |
| |
| public void dispose() { |
| // clean up the known listeners (if there is any remaining) |
| // this will prevent clients from causing memory leaks |
| Set entries = stackToManager.entrySet(); |
| for (Iterator iter = entries.iterator(); iter.hasNext();) { |
| Map.Entry element = (Map.Entry) iter.next(); |
| IOperationHistoryListener historyListener = (IOperationHistoryListener) element.getValue(); |
| if (historyListener != null) { |
| getOperationHistory().removeOperationHistoryListener( |
| historyListener); |
| } |
| } |
| super.dispose(); |
| } |
| |
| } |
