bundles/org.eclipse.core.commands/src/org/eclipse/core/commands/operations/TriggeredOperations.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2005, 2006 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
  *******************************************************************************/
 package org.eclipse.core.commands.operations;

 import java.util.ArrayList;
 import java.util.List;

 import org.eclipse.core.commands.ExecutionException;
 import org.eclipse.core.runtime.IAdaptable;
 import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.core.runtime.OperationCanceledException;
 import org.eclipse.core.runtime.Status;

 /**
  * Triggered operations are a specialized implementation of a composite
  * operation that keeps track of operations triggered by the execution of some
  * primary operation. The composite knows which operation was the trigger for
  * subsequent operations, and adds all triggered operations as children. When
  * execution, undo, or redo is performed, only the triggered operation is
  * executed, undone, or redone if it is still present. If the trigger is removed
  * from the triggered operations, then the child operations will replace the
  * triggered operations in the history.
  * <p>
  * This class may be instantiated by clients.
  * </p>
  *
  * @since 3.1
  */
 public final class TriggeredOperations extends AbstractOperation implements
 		ICompositeOperation, IAdvancedUndoableOperation,
 		IContextReplacingOperation {

 	private IUndoableOperation triggeringOperation;

 	private IOperationHistory history;

 	private List children = new ArrayList();

 	/**
 	 * Construct a composite triggered operations using the specified undoable
 	 * operation as the trigger. Use the label of this trigger as the label of
 	 * the operation.
 	 *
 	 * @param operation
 	 *            the operation that will trigger other operations.
 	 * @param history
 	 *            the operation history containing the triggered operations.
 	 */
 	public TriggeredOperations(IUndoableOperation operation,
 			IOperationHistory history) {
 		super(operation.getLabel());
 		triggeringOperation = operation;
 		recomputeContexts();
 		this.history = history;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IUndoableOperation#add(org.eclipse.core.commands.operations.IUndoableOperation)
 	 */
 	public void add(IUndoableOperation operation) {
 		children.add(operation);
 		recomputeContexts();
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IUndoableOperation#remove(org.eclipse.core.commands.operations.IUndoableOperation)
 	 */
 	public void remove(IUndoableOperation operation) {
 		if (operation == triggeringOperation) {
 			// the triggering operation is being removed, so we must replace
 			// this composite with its individual triggers.
 			triggeringOperation = null;
 			// save the children before replacing the operation, since this
 			// operation will be disposed as part of replacing it. We don't want
 			// the children to be disposed since they are to replace this
 			// operation.
 			List childrenToRestore = new ArrayList(children);
 			children = new ArrayList(0);
 			recomputeContexts();
 			operation.dispose();
 			// now replace the triggering operation
 			history.replaceOperation(this,
 					(IUndoableOperation[]) childrenToRestore
 							.toArray(new IUndoableOperation[childrenToRestore
 									.size()]));
 		} else {
 			children.remove(operation);
 			operation.dispose();
 			recomputeContexts();
 		}
 	}

 	/**
 	 * Remove the specified context from the receiver. This method is typically
 	 * invoked when the history is being flushed for a certain context. In the
 	 * case of triggered operations, if the only context for the triggering
 	 * operation is being removed, then the triggering operation must be
 	 * replaced in the operation history with the atomic operations that it
 	 * triggered. If the context being removed is not the only context for the
 	 * triggering operation, the triggering operation will remain, and the
 	 * children will each be similarly checked.
 	 *
 	 * @param context
 	 *            the undo context being removed from the receiver.
 	 */
 	public void removeContext(IUndoContext context) {

 		boolean recompute = false;
 		// first check to see if we are removing the only context of the
 		// triggering operation
 		if (triggeringOperation != null
 				&& triggeringOperation.hasContext(context)) {
 			if (triggeringOperation.getContexts().length == 1) {
 				remove(triggeringOperation);
 				return;
 			}
 			triggeringOperation.removeContext(context);
 			recompute = true;
 		}
 		// the triggering operation remains, check all the children
 		ArrayList toBeRemoved = new ArrayList();
 		for (int i = 0; i < children.size(); i++) {
 			IUndoableOperation child = (IUndoableOperation) children.get(i);
 			if (child.hasContext(context)) {
 				if (child.getContexts().length == 1) {
 					toBeRemoved.add(child);
 				} else {
 					child.removeContext(context);
 				}
 				recompute = true;
 			}
 		}
 		for (int i = 0; i < toBeRemoved.size(); i++) {
 			remove((IUndoableOperation) toBeRemoved.get(i));
 		}
 		if (recompute) {
 			recomputeContexts();
 		}
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IUndoableOperation#execute(org.eclipse.core.runtime.IProgressMonitor,
 	 *      org.eclipse.core.runtime.IAdaptable)
 	 */
 	public IStatus execute(IProgressMonitor monitor, IAdaptable info)
 			throws ExecutionException {
 		if (triggeringOperation != null) {
 			history.openOperation(this, IOperationHistory.EXECUTE);
 			try {
 				IStatus status = triggeringOperation.execute(monitor, info);
 				history.closeOperation(status.isOK(), false,
 						IOperationHistory.EXECUTE);
 				return status;
 			} catch (ExecutionException e) {
 				history.closeOperation(false, false, IOperationHistory.EXECUTE);
 				throw e;
 			} catch (RuntimeException e) {
 				history.closeOperation(false, false, IOperationHistory.EXECUTE);
 				throw e;
 			}

 		}
 		return IOperationHistory.OPERATION_INVALID_STATUS;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IUndoableOperation#redo(org.eclipse.core.runtime.IProgressMonitor,
 	 *      org.eclipse.core.runtime.IAdaptable)
 	 */
 	public IStatus redo(IProgressMonitor monitor, IAdaptable info)
 			throws ExecutionException {
 		if (triggeringOperation != null) {
 			history.openOperation(this, IOperationHistory.REDO);
 			List childrenToRestore = new ArrayList(children);
 			try {
 				removeAllChildren();
 				IStatus status = triggeringOperation.redo(monitor, info);
 				if (!status.isOK()) {
 					children = childrenToRestore;
 				}
 				history.closeOperation(status.isOK(), false,
 						IOperationHistory.REDO);
 				return status;
 			} catch (ExecutionException e) {
 				children = childrenToRestore;
 				history.closeOperation(false, false, IOperationHistory.REDO);
 				throw e;
 			} catch (RuntimeException e) {
 				children = childrenToRestore;
 				history.closeOperation(false, false, IOperationHistory.REDO);
 				throw e;
 			}
 		}
 		return IOperationHistory.OPERATION_INVALID_STATUS;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IUndoableOperation#undo(org.eclipse.core.runtime.IProgressMonitor,
 	 *      org.eclipse.core.runtime.IAdaptable)
 	 */
 	public IStatus undo(IProgressMonitor monitor, IAdaptable info)
 			throws ExecutionException {
 		if (triggeringOperation != null) {
 			history.openOperation(this, IOperationHistory.UNDO);
 			List childrenToRestore = new ArrayList(children);
 			try {
 				removeAllChildren();
 				IStatus status = triggeringOperation.undo(monitor, info);
 				if (!status.isOK()) {
 					children = childrenToRestore;
 				}
 				history.closeOperation(status.isOK(), false,
 						IOperationHistory.UNDO);
 				return status;
 			} catch (ExecutionException e) {
 				children = childrenToRestore;
 				history.closeOperation(false, false, IOperationHistory.UNDO);
 				throw e;
 			} catch (RuntimeException e) {
 				children = childrenToRestore;
 				history.closeOperation(false, false, IOperationHistory.UNDO);
 				throw e;
 			}
 		}
 		return IOperationHistory.OPERATION_INVALID_STATUS;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IUndoableOperation#canUndo()
 	 */
 	public boolean canUndo() {
 		if (triggeringOperation != null) {
 			return triggeringOperation.canUndo();
 		}
 		return false;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IUndoableOperation#canExecute()
 	 */
 	public boolean canExecute() {
 		if (triggeringOperation != null) {
 			return triggeringOperation.canExecute();
 		}
 		return false;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IUndoableOperation#canRedo()
 	 */
 	public boolean canRedo() {
 		if (triggeringOperation != null) {
 			return triggeringOperation.canRedo();
 		}
 		return false;
 	}

 	/*
 	 * Dispose all operations in the receiver.
 	 */
 	public void dispose() {
 		for (int i = 0; i < children.size(); i++) {
 			((IUndoableOperation) (children.get(i))).dispose();
 		}
 		if (triggeringOperation != null) {
 			triggeringOperation.dispose();
 		}
 	}

 	/*
 	 * Recompute contexts in light of some change in the children
 	 */
 	private void recomputeContexts() {
 		ArrayList allContexts = new ArrayList();
 		if (triggeringOperation != null) {
 			IUndoContext[] contexts = triggeringOperation.getContexts();
 			for (int i = 0; i < contexts.length; i++) {
 				allContexts.add(contexts[i]);
 			}
 		}
 		for (int i = 0; i < children.size(); i++) {
 			IUndoContext[] contexts = ((IUndoableOperation) children.get(i))
 					.getContexts();
 			for (int j = 0; j < contexts.length; j++) {
 				if (!allContexts.contains(contexts[j])) {
 					allContexts.add(contexts[j]);
 				}
 			}
 		}
 		contexts = allContexts;

 	}

 	/*
 	 * Remove all non-triggering children
 	 */
 	private void removeAllChildren() {
 		IUndoableOperation[] nonTriggers = (IUndoableOperation[]) children
 				.toArray(new IUndoableOperation[children.size()]);
 		for (int i = 0; i < nonTriggers.length; i++) {
 			children.remove(nonTriggers[i]);
 			nonTriggers[i].dispose();
 		}
 	}

 	/**
 	 * Return the operation that triggered the other operations in this
 	 * composite.
 	 *
 	 * @return the IUndoableOperation that triggered the other children.
 	 */
 	public IUndoableOperation getTriggeringOperation() {
 		return triggeringOperation;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IAdvancedModelOperation#getAffectedObjects()
 	 */
 	public Object[] getAffectedObjects() {
 		if (triggeringOperation instanceof IAdvancedUndoableOperation) {
 			return ((IAdvancedUndoableOperation) triggeringOperation)
 					.getAffectedObjects();
 		}
 		return null;
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IAdvancedModelOperation#aboutToNotify(org.eclipse.core.commands.operations.OperationHistoryEvent)
 	 */
 	public void aboutToNotify(OperationHistoryEvent event) {
 		if (triggeringOperation instanceof IAdvancedUndoableOperation) {
 			((IAdvancedUndoableOperation) triggeringOperation)
 					.aboutToNotify(event);
 		}
 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)
 	 */
 	public IStatus computeUndoableStatus(IProgressMonitor monitor)
 			throws ExecutionException {
 		if (triggeringOperation instanceof IAdvancedUndoableOperation) {
 			try {
 				return ((IAdvancedUndoableOperation) triggeringOperation)
 						.computeUndoableStatus(monitor);
 			} catch (OperationCanceledException e) {
 				return Status.CANCEL_STATUS;
 			}
 		}
 		return Status.OK_STATUS;

 	}

 	/*
 	 * (non-Javadoc)
 	 *
 	 * @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeRedoableStatus(org.eclipse.core.runtime.IProgressMonitor)
 	 */
 	public IStatus computeRedoableStatus(IProgressMonitor monitor)
 			throws ExecutionException {
 		if (triggeringOperation instanceof IAdvancedUndoableOperation) {
 			try {
 				return ((IAdvancedUndoableOperation) triggeringOperation)
 						.computeRedoableStatus(monitor);
 			} catch (OperationCanceledException e) {
 				return Status.CANCEL_STATUS;
 			}
 		}
 		return Status.OK_STATUS;

 	}

 	/**
 	 * Replace the undo context of the receiver with the provided replacement
 	 * undo context. In the case of triggered operations, all contained
 	 * operations are checked and any occurrence of the original context is
 	 * replaced with the new undo context.
 	 * <p>
 	 * This message has no effect if the original undo context is not present in
 	 * the receiver.
 	 *
 	 * @param original
 	 *            the undo context which is to be replaced
 	 * @param replacement
 	 *            the undo context which is replacing the original
 	 * @since 3.2
 	 */
 	public void replaceContext(IUndoContext original, IUndoContext replacement) {

 		// first check the triggering operation
 		if (triggeringOperation != null
 				&& triggeringOperation.hasContext(original)) {
 			if (triggeringOperation instanceof IContextReplacingOperation) {
 				((IContextReplacingOperation) triggeringOperation)
 						.replaceContext(original, replacement);
 			} else {
 				triggeringOperation.removeContext(original);
 				triggeringOperation.addContext(replacement);
 			}
 		}
 		// Now check all the children
 		for (int i = 0; i < children.size(); i++) {
 			IUndoableOperation child = (IUndoableOperation) children.get(i);
 			if (child.hasContext(original)) {
 				if (child instanceof IContextReplacingOperation) {
 					((IContextReplacingOperation) child).replaceContext(
 							original, replacement);
 				} else {
 					child.removeContext(original);
 					child.addContext(replacement);
 				}
 			}
 		}
 		recomputeContexts();
 	}

 	/**
 	 * Add the specified context to the operation. Overridden in
 	 * TriggeredOperations to add the specified undo context to the triggering
 	 * operation.
 	 *
 	 * @param context
 	 *            the context to be added
 	 *
 	 * @since 3.2
 	 */
 	public void addContext(IUndoContext context) {
 		if (triggeringOperation != null) {
 			triggeringOperation.addContext(context);
 			recomputeContexts();
 		}
 	}

 }
	/*******************************************************************************
	* Copyright (c) 2005, 2006 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
	*******************************************************************************/
	package org.eclipse.core.commands.operations;

	import java.util.ArrayList;
	import java.util.List;

	import org.eclipse.core.commands.ExecutionException;
	import org.eclipse.core.runtime.IAdaptable;
	import org.eclipse.core.runtime.IProgressMonitor;
	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.core.runtime.OperationCanceledException;
	import org.eclipse.core.runtime.Status;

	/**
	* Triggered operations are a specialized implementation of a composite
	* operation that keeps track of operations triggered by the execution of some
	* primary operation. The composite knows which operation was the trigger for
	* subsequent operations, and adds all triggered operations as children. When
	* execution, undo, or redo is performed, only the triggered operation is
	* executed, undone, or redone if it is still present. If the trigger is removed
	* from the triggered operations, then the child operations will replace the
	* triggered operations in the history.
	* <p>
	* This class may be instantiated by clients.
	* </p>
	*
	* @since 3.1
	*/
	public final class TriggeredOperations extends AbstractOperation implements
	ICompositeOperation, IAdvancedUndoableOperation,
	IContextReplacingOperation {

	private IUndoableOperation triggeringOperation;

	private IOperationHistory history;

	private List children = new ArrayList();

	/**
	* Construct a composite triggered operations using the specified undoable
	* operation as the trigger. Use the label of this trigger as the label of
	* the operation.
	*
	* @param operation
	* the operation that will trigger other operations.
	* @param history
	* the operation history containing the triggered operations.
	*/
	public TriggeredOperations(IUndoableOperation operation,
	IOperationHistory history) {
	super(operation.getLabel());
	triggeringOperation = operation;
	recomputeContexts();
	this.history = history;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IUndoableOperation#add(org.eclipse.core.commands.operations.IUndoableOperation)
	*/
	public void add(IUndoableOperation operation) {
	children.add(operation);
	recomputeContexts();
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IUndoableOperation#remove(org.eclipse.core.commands.operations.IUndoableOperation)
	*/
	public void remove(IUndoableOperation operation) {
	if (operation == triggeringOperation) {
	// the triggering operation is being removed, so we must replace
	// this composite with its individual triggers.
	triggeringOperation = null;
	// save the children before replacing the operation, since this
	// operation will be disposed as part of replacing it. We don't want
	// the children to be disposed since they are to replace this
	// operation.
	List childrenToRestore = new ArrayList(children);
	children = new ArrayList(0);
	recomputeContexts();
	operation.dispose();
	// now replace the triggering operation
	history.replaceOperation(this,
	(IUndoableOperation[]) childrenToRestore
	.toArray(new IUndoableOperation[childrenToRestore
	.size()]));
	} else {
	children.remove(operation);
	operation.dispose();
	recomputeContexts();
	}
	}

	/**
	* Remove the specified context from the receiver. This method is typically
	* invoked when the history is being flushed for a certain context. In the
	* case of triggered operations, if the only context for the triggering
	* operation is being removed, then the triggering operation must be
	* replaced in the operation history with the atomic operations that it
	* triggered. If the context being removed is not the only context for the
	* triggering operation, the triggering operation will remain, and the
	* children will each be similarly checked.
	*
	* @param context
	* the undo context being removed from the receiver.
	*/
	public void removeContext(IUndoContext context) {

	boolean recompute = false;
	// first check to see if we are removing the only context of the
	// triggering operation
	if (triggeringOperation != null
	&& triggeringOperation.hasContext(context)) {
	if (triggeringOperation.getContexts().length == 1) {
	remove(triggeringOperation);
	return;
	}
	triggeringOperation.removeContext(context);
	recompute = true;
	}
	// the triggering operation remains, check all the children
	ArrayList toBeRemoved = new ArrayList();
	for (int i = 0; i < children.size(); i++) {
	IUndoableOperation child = (IUndoableOperation) children.get(i);
	if (child.hasContext(context)) {
	if (child.getContexts().length == 1) {
	toBeRemoved.add(child);
	} else {
	child.removeContext(context);
	}
	recompute = true;
	}
	}
	for (int i = 0; i < toBeRemoved.size(); i++) {
	remove((IUndoableOperation) toBeRemoved.get(i));
	}
	if (recompute) {
	recomputeContexts();
	}
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IUndoableOperation#execute(org.eclipse.core.runtime.IProgressMonitor,
	* org.eclipse.core.runtime.IAdaptable)
	*/
	public IStatus execute(IProgressMonitor monitor, IAdaptable info)
	throws ExecutionException {
	if (triggeringOperation != null) {
	history.openOperation(this, IOperationHistory.EXECUTE);
	try {
	IStatus status = triggeringOperation.execute(monitor, info);
	history.closeOperation(status.isOK(), false,
	IOperationHistory.EXECUTE);
	return status;
	} catch (ExecutionException e) {
	history.closeOperation(false, false, IOperationHistory.EXECUTE);
	throw e;
	} catch (RuntimeException e) {
	history.closeOperation(false, false, IOperationHistory.EXECUTE);
	throw e;
	}

	}
	return IOperationHistory.OPERATION_INVALID_STATUS;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IUndoableOperation#redo(org.eclipse.core.runtime.IProgressMonitor,
	* org.eclipse.core.runtime.IAdaptable)
	*/
	public IStatus redo(IProgressMonitor monitor, IAdaptable info)
	throws ExecutionException {
	if (triggeringOperation != null) {
	history.openOperation(this, IOperationHistory.REDO);
	List childrenToRestore = new ArrayList(children);
	try {
	removeAllChildren();
	IStatus status = triggeringOperation.redo(monitor, info);
	if (!status.isOK()) {
	children = childrenToRestore;
	}
	history.closeOperation(status.isOK(), false,
	IOperationHistory.REDO);
	return status;
	} catch (ExecutionException e) {
	children = childrenToRestore;
	history.closeOperation(false, false, IOperationHistory.REDO);
	throw e;
	} catch (RuntimeException e) {
	children = childrenToRestore;
	history.closeOperation(false, false, IOperationHistory.REDO);
	throw e;
	}
	}
	return IOperationHistory.OPERATION_INVALID_STATUS;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IUndoableOperation#undo(org.eclipse.core.runtime.IProgressMonitor,
	* org.eclipse.core.runtime.IAdaptable)
	*/
	public IStatus undo(IProgressMonitor monitor, IAdaptable info)
	throws ExecutionException {
	if (triggeringOperation != null) {
	history.openOperation(this, IOperationHistory.UNDO);
	List childrenToRestore = new ArrayList(children);
	try {
	removeAllChildren();
	IStatus status = triggeringOperation.undo(monitor, info);
	if (!status.isOK()) {
	children = childrenToRestore;
	}
	history.closeOperation(status.isOK(), false,
	IOperationHistory.UNDO);
	return status;
	} catch (ExecutionException e) {
	children = childrenToRestore;
	history.closeOperation(false, false, IOperationHistory.UNDO);
	throw e;
	} catch (RuntimeException e) {
	children = childrenToRestore;
	history.closeOperation(false, false, IOperationHistory.UNDO);
	throw e;
	}
	}
	return IOperationHistory.OPERATION_INVALID_STATUS;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IUndoableOperation#canUndo()
	*/
	public boolean canUndo() {
	if (triggeringOperation != null) {
	return triggeringOperation.canUndo();
	}
	return false;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IUndoableOperation#canExecute()
	*/
	public boolean canExecute() {
	if (triggeringOperation != null) {
	return triggeringOperation.canExecute();
	}
	return false;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IUndoableOperation#canRedo()
	*/
	public boolean canRedo() {
	if (triggeringOperation != null) {
	return triggeringOperation.canRedo();
	}
	return false;
	}

	/*
	* Dispose all operations in the receiver.
	*/
	public void dispose() {
	for (int i = 0; i < children.size(); i++) {
	((IUndoableOperation) (children.get(i))).dispose();
	}
	if (triggeringOperation != null) {
	triggeringOperation.dispose();
	}
	}

	/*
	* Recompute contexts in light of some change in the children
	*/
	private void recomputeContexts() {
	ArrayList allContexts = new ArrayList();
	if (triggeringOperation != null) {
	IUndoContext[] contexts = triggeringOperation.getContexts();
	for (int i = 0; i < contexts.length; i++) {
	allContexts.add(contexts[i]);
	}
	}
	for (int i = 0; i < children.size(); i++) {
	IUndoContext[] contexts = ((IUndoableOperation) children.get(i))
	.getContexts();
	for (int j = 0; j < contexts.length; j++) {
	if (!allContexts.contains(contexts[j])) {
	allContexts.add(contexts[j]);
	}
	}
	}
	contexts = allContexts;

	}

	/*
	* Remove all non-triggering children
	*/
	private void removeAllChildren() {
	IUndoableOperation[] nonTriggers = (IUndoableOperation[]) children
	.toArray(new IUndoableOperation[children.size()]);
	for (int i = 0; i < nonTriggers.length; i++) {
	children.remove(nonTriggers[i]);
	nonTriggers[i].dispose();
	}
	}

	/**
	* Return the operation that triggered the other operations in this
	* composite.
	*
	* @return the IUndoableOperation that triggered the other children.
	*/
	public IUndoableOperation getTriggeringOperation() {
	return triggeringOperation;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IAdvancedModelOperation#getAffectedObjects()
	*/
	public Object[] getAffectedObjects() {
	if (triggeringOperation instanceof IAdvancedUndoableOperation) {
	return ((IAdvancedUndoableOperation) triggeringOperation)
	.getAffectedObjects();
	}
	return null;
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IAdvancedModelOperation#aboutToNotify(org.eclipse.core.commands.operations.OperationHistoryEvent)
	*/
	public void aboutToNotify(OperationHistoryEvent event) {
	if (triggeringOperation instanceof IAdvancedUndoableOperation) {
	((IAdvancedUndoableOperation) triggeringOperation)
	.aboutToNotify(event);
	}
	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeUndoableStatus(org.eclipse.core.runtime.IProgressMonitor)
	*/
	public IStatus computeUndoableStatus(IProgressMonitor monitor)
	throws ExecutionException {
	if (triggeringOperation instanceof IAdvancedUndoableOperation) {
	try {
	return ((IAdvancedUndoableOperation) triggeringOperation)
	.computeUndoableStatus(monitor);
	} catch (OperationCanceledException e) {
	return Status.CANCEL_STATUS;
	}
	}
	return Status.OK_STATUS;

	}

	/*
	* (non-Javadoc)
	*
	* @see org.eclipse.core.commands.operations.IAdvancedUndoableOperation#computeRedoableStatus(org.eclipse.core.runtime.IProgressMonitor)
	*/
	public IStatus computeRedoableStatus(IProgressMonitor monitor)
	throws ExecutionException {
	if (triggeringOperation instanceof IAdvancedUndoableOperation) {
	try {
	return ((IAdvancedUndoableOperation) triggeringOperation)
	.computeRedoableStatus(monitor);
	} catch (OperationCanceledException e) {
	return Status.CANCEL_STATUS;
	}
	}
	return Status.OK_STATUS;

	}

	/**
	* Replace the undo context of the receiver with the provided replacement
	* undo context. In the case of triggered operations, all contained
	* operations are checked and any occurrence of the original context is
	* replaced with the new undo context.
	* <p>
	* This message has no effect if the original undo context is not present in
	* the receiver.
	*
	* @param original
	* the undo context which is to be replaced
	* @param replacement
	* the undo context which is replacing the original
	* @since 3.2
	*/
	public void replaceContext(IUndoContext original, IUndoContext replacement) {

	// first check the triggering operation
	if (triggeringOperation != null
	&& triggeringOperation.hasContext(original)) {
	if (triggeringOperation instanceof IContextReplacingOperation) {
	((IContextReplacingOperation) triggeringOperation)
	.replaceContext(original, replacement);
	} else {
	triggeringOperation.removeContext(original);
	triggeringOperation.addContext(replacement);
	}
	}
	// Now check all the children
	for (int i = 0; i < children.size(); i++) {
	IUndoableOperation child = (IUndoableOperation) children.get(i);
	if (child.hasContext(original)) {
	if (child instanceof IContextReplacingOperation) {
	((IContextReplacingOperation) child).replaceContext(
	original, replacement);
	} else {
	child.removeContext(original);
	child.addContext(replacement);
	}
	}
	}
	recomputeContexts();
	}

	/**
	* Add the specified context to the operation. Overridden in
	* TriggeredOperations to add the specified undo context to the triggering
	* operation.
	*
	* @param context
	* the context to be added
	*
	* @since 3.2
	*/
	public void addContext(IUndoContext context) {
	if (triggeringOperation != null) {
	triggeringOperation.addContext(context);
	recomputeContexts();
	}
	}

	}