*   Zeligsoft - Bug 240775

 *   Zeligsoft - Bug 240775

		stack.setResourceUndoContextPolicy(getResourceUndoContextPolicy());

		stack.setResourceUndoContextPolicy(getResourceUndoContextPolicy());

	/**

	 * Obtains a resource undo-context policy to apply to the editing domain, to

	 * determine how to attach {@link ResourceUndoContext}s to operations in the

	 * associated history.  May be overridden by clients to supply a non-default

	 * implementation.

	 * 

	 * @return the resource undo-context policy

	 * 

	 * @since 1.3

	 */

	protected IResourceUndoContextPolicy getResourceUndoContextPolicy() {

		return IResourceUndoContextPolicy.DEFAULT;

	}

import org.eclipse.emf.workspace.IResourceUndoContextPolicy;

	/**

	 * Obtains my resource undo-context policy.

	 * 

	 * @return my resource undo-context policy

	 * 

	 * @since 1.3

	 */

	public IResourceUndoContextPolicy getResourceUndoContextPolicy() {

		return undoContextPolicy;

	}

	/**

	 * Sets my resource undo-context policy.

	 * 

	 * @param policy

	 *            my new policy, or <code>null</code> to restore the default

	 * 

	 * @since 1.3

	 */

	public void setResourceUndoContextPolicy(IResourceUndoContextPolicy policy) {

		this.undoContextPolicy = policy;

	}

					currentOperation = operation;

					currentOperation = null;

					currentOperation = null;

            Transaction tx = event.getTransaction();

            if (tx != null) {

                operation = (IUndoableOperation) tx.getOptions().get(

                    EMFWorkspacePlugin.OPTION_OWNING_OPERATION);

            }

/**

 * <copyright>

 * 

 * Copyright (c) 2008 Zeligsoft Inc. 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:

 *   Zeligsoft - Initial API and implementation

 * 

 * </copyright>

 *

 * $Id$

 */

package org.eclipse.emf.workspace;

import java.util.Collection;

import java.util.Collections;

import java.util.List;

import java.util.Set;

import org.eclipse.core.commands.operations.IUndoableOperation;

import org.eclipse.emf.common.notify.Notification;

import org.eclipse.emf.ecore.EObject;

import org.eclipse.emf.ecore.EReference;

import org.eclipse.emf.ecore.resource.Resource;

/**

 * <p>

 * The default implementation of the resource undo-context policy, suitable for

 * clients to extend/override as required. The default policy is to consider any

 * resource as affected by an operation if either

 * </p>

 * <ol>

 * <li>A non-touch {@link Notification} is received from a contained object or

 * from the resource, itself, or</li>

 * <li>A notification matching (1) is received from a uni-directional

 * {@link EReference} (i.e., one having no opposite) has an old value or a new

 * value in the resource

 * </ol>

 * <p>

 * In the first case, above, a subclass can choose to include only changes to a

 * resource's contents-list and URI as being significant (other resource

 * properties not affecting the serialization of the resource).

 * </p>

 * <p>

 * The second case, above, is intended for applications that use

 * {@link ResourceUndoContext}s to manage the Undo menus of their editors. It is

 * a pessimistic assumption that the referenced resource may either have derived

 * attributes whose values influenced precursor or successor operations, or that

 * such operations are influenced by the references incoming to the resource.

 * Thus, the concern is not so much with the dirty state of the resource as it

 * is with the integrity of the undo history for the associated editor and the

 * dependencies between successive operations. Subclasses can disable this case

 * by overriding the {@link #pessimisticCrossReferences()} method.

 * </p>

 * 

 * @author Christian W. Damus (cdamus)

 * @since 1.3

 * 

 * @see #pessimisticCrossReferences()

 * @see #considerAllResourceChanges()

 */

public abstract class AbstractResourceUndoContextPolicy

		implements IResourceUndoContextPolicy {

	/**

	 * Initializes me.

	 */

	protected AbstractResourceUndoContextPolicy() {

		super();

	}

	public Set<Resource> getContextResources(IUndoableOperation operation,

			List<? extends Notification> notifications) {

		Set<Resource> result;

		if (notifications.isEmpty()) {

			result = Collections.emptySet();

		} else {

			result = new java.util.HashSet<Resource>();

			for (Notification next : notifications) {

				if (next.isTouch()) {

					continue;

				}

				Object notifier = next.getNotifier();

				if (notifier instanceof Resource) {

					if (considerAllResourceChanges()

						|| (next.getFeatureID(Resource.class) == Resource.RESOURCE__CONTENTS)

						|| (next.getFeatureID(Resource.class) == Resource.RESOURCE__URI)) {

						result.add((Resource) notifier);

					}

				} else if (notifier instanceof EObject) {

					EObject eobj = (EObject) notifier;

					Resource resource = eobj.eResource();

					if (resource != null) {

						result.add(resource);

					}

					if (pessimisticCrossReferences()) {

						// if the reference has an opposite, then we will get

						// the

						// notification from the other end, anyway

						final Object feature = next.getFeature();

						if ((feature instanceof EReference)

							&& (((EReference) feature).getEOpposite() == null)) {

							handleCrossResourceReference(result, next);

						}

					}

				}

			}

		}

		return result;

	}

	/**

	 * May be overridden by subclasses to disable pessimistic handling of

	 * cross-resource references. The default implementation returns

	 * <code>true</code> always.

	 * 

	 * @return whether to consider changes to directed cross-resource references

	 *         as affecting the referenced resource

	 */

	protected boolean pessimisticCrossReferences() {

		return true;

	}

	/**

	 * May be overridden by subclasses to consider changes to any feature of a

	 * resource, not just its contents-list or URI, as affecting it.

	 * 

	 * @return <code>true</code> if all changes to a resource are considered as

	 *         affecting it for the purposes of undo context; <code>false</code>

	 *         if only the contents-list and URI are

	 */

	protected boolean considerAllResourceChanges() {

		return false;

	}

	/**

	 * Handles notifications that can potentially represent cross-resource

	 * references. Helper to the

	 * {@link #getContextResources(IUndoableOperation, List)} method.

	 * 

	 * @param resources

	 *            collects the affected resources

	 * @param notification

	 *            a potential cross-resource reference change notification

	 */

	protected void handleCrossResourceReference(Set<Resource> resources,

			Notification notification) {

		Object oldValue = notification.getOldValue();

		Object newValue = notification.getNewValue();

		Resource resource;

		switch (notification.getEventType()) {

			case Notification.SET :

			case Notification.UNSET :

				if (oldValue != null) {

					resource = ((EObject) oldValue).eResource();

					if (resource != null) {

						resources.add(resource);

					}

				}

				if (newValue != null) {

					resource = ((EObject) newValue).eResource();

					if (resource != null) {

						resources.add(resource);

					}

				}

				break;

			case Notification.ADD :

				resource = ((EObject) newValue).eResource();

				if (resource != null) {

					resources.add(resource);

				}

				break;

			case Notification.ADD_MANY : {

				@SuppressWarnings("unchecked")

				Collection<EObject> newReferences = (Collection<EObject>) newValue;

				for (EObject next : newReferences) {

					resource = next.eResource();

					if (resource != null) {

						resources.add(resource);

					}

				}

				break;

			}

			case Notification.REMOVE :

				resource = ((EObject) oldValue).eResource();

				if (resource != null) {

					resources.add(resource);

				}

				break;

			case Notification.REMOVE_MANY : {

				@SuppressWarnings("unchecked")

				Collection<EObject> oldReferences = (Collection<EObject>) oldValue;

				for (EObject next : oldReferences) {

					resource = next.eResource();

					if (resource != null) {

						resources.add(resource);

					}

				}

				break;

			}

		}

	}

}

/**

 * <copyright>

 * 

 * Copyright (c) 2008 Zeligsoft Inc. 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:

 *   Zeligsoft - Initial API and implementation

 * 

 * </copyright>

 *

 * $Id$

 */

package org.eclipse.emf.workspace;

import java.util.List;

import java.util.Set;

import org.eclipse.core.commands.operations.IUndoableOperation;

import org.eclipse.emf.common.notify.Notification;

import org.eclipse.emf.ecore.resource.Resource;

/**

 * <p>

 * A rule determining the resources for which an {@link IUndoableOperation}

 * should be tagged with {@link ResourceUndoContext}s. In general, these are the

 * resources that

 * </p>

 * <ul>

 * <li>are modified by the operation, such that they are become dirty, and/or</li>

 * <li>whose editors should show the operation in their Undo menu</li>

 * </ul>

 * <p>

 * Clients may implement this interface, but it is recommended to extend the

 * {@link AbstractResourceUndoContextPolicy} class whenever possible.

 * </p>

 * 

 * @author Christian W. Damus (cdamus)

 * @since 1.3

 * 

 * @see AbstractResourceUndoContextPolicy

 */

public interface IResourceUndoContextPolicy {

	/**

	 * The default undo-context policy used by editing domains for which none is

	 * assigned by the client application.

	 */

	IResourceUndoContextPolicy DEFAULT = new AbstractResourceUndoContextPolicy() {

	};

	/**

	 * Determines the resources in the undo context of the specified

	 * <tt>operation</tt>, during which execution the changes indicated by the

	 * given <tt>notifications</tt> occurred. This operation may be called

	 * several times for the same operation, but always with different

	 * notifications.

	 * 

	 * @param operation

	 *            the operation. It may or may not have finished executing. Must

	 *            not be <code>null</code>

	 * @param notifications

	 *            a list of notifications of changes caused by the operation

	 *            during its execution, in the order in which they occurred.

	 *            This may be an empty list, but never <code>null</code>

	 * 

	 * @return the resources that are the undo context of this operation, or an

	 *         empty list if none. Never ruterns <code>null</code>

	 */

	Set<Resource> getContextResources(IUndoableOperation operation,

			List<? extends Notification> notifications);

}