plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/util/clipboard/ModelClipboard.java

/*******************************************************************************
 * <copyright>
 *
 * Copyright (c) 2005, 2012 SAP AG.
 * 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:
 *    SAP AG - initial API, implementation and documentation
 *    mwenz - Felix Velasco - Bug 374918 - Let default paste use LocalSelectionTransfer
 *    mwenz - Felix Velasco - Bug 361414 - Copy/paste : clipboard contents confuses the workbench
 *
 * </copyright>
 *
 *******************************************************************************/
package org.eclipse.graphiti.ui.internal.util.clipboard;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IResource;
import org.eclipse.core.runtime.OperationCanceledException;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.command.CommandStack;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EClassifier;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EReference;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.util.EcoreUtil.Copier;
import org.eclipse.emf.transaction.RecordingCommand;
import org.eclipse.emf.transaction.TransactionalEditingDomain;
import org.eclipse.emf.transaction.util.TransactionUtil;
import org.eclipse.graphiti.ui.internal.Messages;
import org.eclipse.graphiti.ui.internal.T;
import org.eclipse.graphiti.ui.internal.services.GraphitiUiInternal;
import org.eclipse.graphiti.ui.internal.util.ReflectionUtil;
import org.eclipse.jface.util.LocalSelectionTransfer;
import org.eclipse.jface.viewers.ISelection;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.jface.viewers.StructuredSelection;
import org.eclipse.swt.custom.BusyIndicator;
import org.eclipse.swt.dnd.Clipboard;
import org.eclipse.swt.dnd.FileTransfer;
import org.eclipse.swt.dnd.TextTransfer;
import org.eclipse.swt.dnd.Transfer;
import org.eclipse.swt.widgets.Display;

/**
 * Provides a clipboard-like storage of EMF-related data based on SWT
 * {@link Clipboard}.
 * 
 * @noinstantiate This class is not intended to be instantiated by clients.
 * @noextend This class is not intended to be subclassed by clients.
 */
public final class ModelClipboard {

	private static final String EMPTY_TOSTRING_PLACEHOLDER = "<empty>"; //$NON-NLS-1$
	private static final EObject[] NO_E_OBJECTS = new EObject[0];
	private static final ModelClipboard INSTANCE = new ModelClipboard();

	/**
	 * Creates a {@link ModelClipboard}.
	 */
	private ModelClipboard() {
	}

	/**
	 * @return the default {@link ModelClipboard} instance to represent a global
	 *         {@link ModelClipboard} to the user, which is connected to the SWT
	 *         {@link Clipboard}.
	 */
	public static ModelClipboard getDefault() {
		return INSTANCE;
	}

	/**
	 * Sets the content of the {@link Clipboard} and deletes all previous data.
	 * Must be called in the UI thread.
	 * 
	 * @param objects
	 *            the {@link EObject} <code>objects</code> to store
	 * @throws IllegalStateException
	 *             if not called from UI thread
	 * @throws IllegalArgumentException
	 *             if <code>objects</code> parameter is null
	 */
	public synchronized void setContent(EObject[] objects) throws IllegalStateException {
		if (objects == null) {
			throw new IllegalArgumentException("EObject[] objects must not be null"); //$NON-NLS-1$
		}
		if (objects.length == 0) {
			return;
		}
		if (canUseNative()) {
			// must run in UI thread
			setNativeContentObjects(Arrays.asList(objects));
		}
	}

	/**
	 * Returns the SWT {@link Clipboard} content in form of {@link EObject}s.
	 * 
	 * @param resourceSet
	 *            the ResourceSet to resolve the stored URI information
	 * @return the content as live objects
	 * @throws IllegalStateException
	 *             if not called from UI thread
	 * @throws IllegalArgumentException
	 *             if <code>resourceSet</code> parameter is null
	 */
	public synchronized EObject[] getContentAsEObjects(ResourceSet resourceSet) throws IllegalStateException {
		if (resourceSet == null) {
			throw new IllegalArgumentException("ResourceSet resourceSet must not be null"); //$NON-NLS-1$
		}
		final List<EObject> eObjectList;
		if (canUseNative()) {
			eObjectList = getLocalSelectionContent();
		} else {
			eObjectList = Collections.emptyList();
		}
		if (eObjectList.isEmpty()) {
			return NO_E_OBJECTS;
		}
		return eObjectList.toArray(new EObject[eObjectList.size()]);
	}

	private List<EObject> getLocalSelectionContent() {
		final Clipboard cb = new Clipboard(Display.getCurrent());
		try {
			final ISelection contents = (ISelection) cb.getContents(LocalSelectionTransfer.getTransfer());
			if (contents instanceof IStructuredSelection && !contents.isEmpty()) {
				List<?> list = ((IStructuredSelection) contents).toList();
				for (Object o : list) {
					if (!(o instanceof EObject))
						return Collections.emptyList();
				}
				@SuppressWarnings("unchecked")
				List<EObject> localList = (List<EObject>) list;
				return localList;
			}
			return Collections.emptyList();
		} finally {
			cb.dispose();
		}
	}

	/**
	 * Answers whether at least one of the given objects can be aggregated below
	 * the given parent as composite children. This generic implementation
	 * considers type compatibility and cardinalities but no additional domain
	 * specific constraints.
	 * 
	 * @param parent
	 *            the composite parent
	 * @param objects
	 *            the objects to check
	 * @return <code>true</code> if at least one object may be a composite child
	 *         of <code>parent</code>
	 */
	public boolean isCompositionAllowed(EObject parent, EObject[] objects) {
		for (final EObject object : objects) {
			// optimistic approach: if one association can aggregate one
			// element, we are OK
			final List<EReference> assocs = findUsableTargetAssociations(parent, object);
			if (assocs.size() > 0) {
				return true;
			}
		}
		return false;
	}

	/**
	 * Duplicates the clipboard's content using EMF's deep copy service. Note
	 * that only elements from the content that are {@link EObject}s are
	 * considered, pure {@link EObject}s like packages cannot be duplicated.
	 * 
	 * @param target
	 *            an object acting as composite parent for the copies.
	 *            <code>null</code> if the copied elements should be top-level
	 *            elements.
	 * @param transactionalEditingDomain
	 *            the TransactionalEditingDomain to write the copies into. Must
	 *            not be <code>null</code> nor dead.
	 * @return the copy result or <code>null</code> in case of an empty
	 *         clipboard
	 * @throws IllegalStateException
	 *             if not called from UI thread
	 * @throws IllegalArgumentException
	 *             if <code>transactionalEditingDomain</code> parameter is null
	 * @throws IllegalArgumentException
	 *             if <code>transactionalEditingDomain</code> parameter is not
	 *             equal to the TransactionalEditingDomain of
	 *             <code>target</code> parameter
	 * @see #isCompositionAllowed(EObject, EObject[])
	 * @see #getContentAsEObjects(ResourceSet)
	 */
	@SuppressWarnings("unchecked")
	public Collection<EObject> duplicateAndPaste(final Object target, TransactionalEditingDomain transactionalEditingDomain)
			throws IllegalStateException {

		if (transactionalEditingDomain == null) {
			throw new IllegalStateException("TransactionalEditingDomain targetConnection should not be null"); //$NON-NLS-1$
		}
		final EObject parent = GraphitiUiInternal.getEmfService().getEObject(target);
		if (parent != null) {
			// detect TransactionalEditingDomain mismatch to prevent
			// modification of wrong object
			final TransactionalEditingDomain parentEditingDomain = TransactionUtil.getEditingDomain(parent);
			if (parentEditingDomain != null && !transactionalEditingDomain.equals(parentEditingDomain)) {
				throw new IllegalStateException(
						"Ambiguous TransactionalEditingDomains: transactionalEditingDomain: " + transactionalEditingDomain //$NON-NLS-1$
								+ " <-> TransactionalEditingDomain of target object: " + parentEditingDomain //$NON-NLS-1$
								+ ". Not clear which one to use for copy."); //$NON-NLS-1$
			}
		}

		EObject[] srcObjects;
		try {
			srcObjects = getContentAsEObjects(transactionalEditingDomain.getResourceSet());
			if (srcObjects.length == 0) {
				return null; // no or no resolvable objects in clipboard
			}

		} catch (final OperationCanceledException e) { // $JL-EXC$
			return null;
		} catch (final Exception e) { // $JL-EXC$
			T.racer().error(e.getMessage(), e);
			return null;
		}

		// subsequent operations run in a command and are rolled back in case of
		// errors
		final CommandStack commandStack = transactionalEditingDomain.getCommandStack();
		final Collection<EObject>[] copyResults = new Collection[1];
		try {
			final EObject[] srcObjectsFinal = srcObjects;
			final RecordingCommand command = new CopyCommand(transactionalEditingDomain, parent, srcObjectsFinal, copyResults);
			commandStack.execute(command);
			// commit
			return copyResults[0];
		} catch (final OperationCanceledException e) { // $JL-EXC$
			// user cancelled
			rollback(transactionalEditingDomain);
			return null;
		} catch (final Exception e) { // $JL-EXC$
			// unspecific error
			T.racer().error(e.getMessage(), e);
			rollback(transactionalEditingDomain);
			return null;
		}
	}

	@SuppressWarnings("unchecked")
	private Collection<EObject> deepCopy(final EObject[] srcObjects) {
		if (srcObjects == null) {
			throw new IllegalArgumentException("EObject[] srcObjects must not be null"); //$NON-NLS-1$
		}
		if (srcObjects.length == 0) {
			throw new IllegalArgumentException("EObject[] srcObjects.length must not be 0"); //$NON-NLS-1$
		}
		final Collection<EObject>[] result = new Collection[1];
		// in the case of a UI
		if (canUseUI()) {
			BusyIndicator.showWhile(Display.getCurrent(), new Runnable() {
				public void run() {
					final Copier copier = new Copier(true, true);
					result[0] = copier.copyAll(Arrays.asList(srcObjects));
					copier.copyReferences();
				}
			});
			return result[0];
		}

		// in the non-UI case
		final Copier copier = new Copier(true, true);
		result[0] = copier.copyAll(Arrays.asList(srcObjects));
		copier.copyReferences();
		return result[0];
	}

	/**
	 * Adds the given elements to <code>parent</code> as composite children.s
	 * 
	 * @param parent
	 *            parent to add the objects to. Must not be <code>null</code>.
	 * @param objects
	 *            the objects to add
	 * @param association
	 *            an explicit association or <code>null</code>
	 */
	private void addToCompositeParent(EObject parent, EObject[] objects, EReference association) {
		if (parent == null) {
			throw new IllegalStateException("Parent must not be null"); //$NON-NLS-1$
		}

		for (final EObject object : objects) {
			final EObject objectParent = object.eContainer();
			if (objectParent != null) {
				if (T.racer().debug()) {
					final String msg = "Ignoring " + toObjectString(object) //$NON-NLS-1$
							+ " for parent assignment. Already assigned to " + toObjectString(objectParent); //$NON-NLS-1$
					T.racer().debug(msg);
				}
				continue;
			}
			// Find the composition relationships to use between parent and
			// child
			final List<EReference> assocs = findUsableTargetAssociations(parent, object);
			EReference assoc;

			switch (assocs.size()) {
			case 0:
				final String msg = "No composite associations found for " //$NON-NLS-1$
						+ toObjectString(parent.eClass()) + " -> " //$NON-NLS-1$
						+ toObjectString(object.eClass());
				// Don't issue an error here. The client might already have
				// composed the objects.
				T.racer().debug(msg);
				continue;
			case 1:
				assoc = assocs.get(0);
				break;
			default: // multiple associations
				if (association != null) {
					if (!assocs.contains(association)) {
						throw new IllegalStateException("Given association " + association.getName() //$NON-NLS-1$
								+ " not valid among " + toAssociationNames(assocs)); //$NON-NLS-1$
					}
					assoc = association;
					break;
				} else {
					throw new IllegalStateException("Multiple associations available " //$NON-NLS-1$
							+ toAssociationNames(assocs));
				}
			}

			// Use the obtained association to compose the child into the parent
			compose(parent, object, assoc);
		}
	}

	private static List<String> toAssociationNames(List<EReference> assocs) {
		final List<String> names = new ArrayList<String>(assocs.size());
		for (final EReference assoc : assocs) {
			names.add(assoc.getName());
		}
		return names;
	}

	private static String toObjectString(Object o) {
		if (o instanceof Collection<?>) {
			return toObjectsString((Collection<?>) o);
		}
		return toObjectsString(Collections.singleton(o));
	}

	private static String toObjectsString(Collection<?> objects) {
		final StringBuilder b = new StringBuilder();
		for (final Object o : objects) {
			if (o instanceof EObject) {
				final EObject object = (EObject) o;
				final String name = GraphitiUiInternal.getEmfService().getObjectName(object);
				final String type = object.eClass().getName();
				b.append(type).append(" '").append(name).append("'"); //$NON-NLS-1$ //$NON-NLS-2$
			} else {
				b.append(o);
			}
		}
		return b.toString();
	}

	/**
	 * Adds the given child to the given parent in the given association.
	 */
	@SuppressWarnings("unchecked")
	private static void compose(EObject parent, EObject child, EReference assoc) {
		final Object o = parent.eGet(assoc, true);
		if (o instanceof List<?>) {
			final List<EObject> list = (List<EObject>) o;
			list.add(child);
		} else {
			parent.eSet(assoc, child);
		}
	}

	/**
	 * @return all copied elements from <code>result</code> that originate from
	 *         root elements in the source
	 */
	private Map<EObject, EObject> getTargetRootElements(Collection<EObject> result, EObject[] srcElements) {
		final Map<EObject, EObject> elements = new LinkedHashMap<EObject, EObject>(srcElements.length);
		EObject[] resultArray = new EObject[result.size()];
		resultArray = result.toArray(resultArray);
		for (int i = 0; i < srcElements.length; i++) {
			elements.put(resultArray[i], srcElements[i]);
		}
		return elements;
	}

	/**
	 * Finds all composite associations for the given <code>parent</code> object
	 * that reference a child of type <code>child</code>. Associations that have
	 * a upper cardinality of '1' are not contained in the returned
	 * <code>List</code>.
	 * 
	 * @param parent
	 *            the composite parent element.
	 * @param child
	 *            the <code>EObject</code> defining the type of the composite
	 *            children.
	 * @return the list containing all composite associations that fulfil the
	 *         selection criteria described above.
	 */
	static List<EReference> findUsableTargetAssociations(EObject parent, EObject child) {
		final List<EReference> compositeAssociations = new ArrayList<EReference>();

		final Collection<EReference> contents = getContainmentReferences(parent.eClass());
		for (final Iterator<EReference> iterator = contents.iterator(); iterator.hasNext();) {
			final EReference reference = iterator.next();
			final EClassifier referenceType = reference.getEType();
			if (referenceType.isInstance(child)) {
				final Object value = parent.eGet(reference);
				if (reference.getUpperBound() != 1 || value == null) {
					compositeAssociations.add(reference);
				}
			}

		}
		return compositeAssociations;
	}

	private static Collection<EReference> getContainmentReferences(EClass eclass) {
		final Collection<EReference> assocs = new ArrayList<EReference>();
		final EList<EObject> contents = eclass.eContents();
		for (final Iterator<EObject> iterator = contents.iterator(); iterator.hasNext();) {
			final EObject object = iterator.next();
			if (object instanceof EReference) {
				final EReference reference = (EReference) object;
				if (reference.isContainment()) {
					assocs.add(reference);
				}
			}
		}

		final EList<EClass> superTypes = eclass.getESuperTypes();
		for (final Iterator<EClass> iterator = superTypes.iterator(); iterator.hasNext();) {
			assocs.addAll(getContainmentReferences(iterator.next()));
		}

		return assocs;
	}

	/**
	 * Reverts the active command group.
	 */
	private void rollback(final TransactionalEditingDomain targetTED) {
		try {
			targetTED.runExclusive(new Runnable() {
				public void run() {
					final EList<Resource> resources = targetTED.getResourceSet().getResources();
					for (final Iterator<Resource> iterator = resources.iterator(); iterator.hasNext();) {
						final Resource resource = iterator.next();
						resource.unload();
						resource.setModified(false);
					}
				}
			});
		} catch (final InterruptedException e) {
		}
	}

	private synchronized List<String> getContentAsStringList() {
		List<String> strings = Collections.emptyList();
		if (canUseNative()) {
			// must run in UI thread
			strings = getNativeContent();
		}
		return strings;
	}

	/**
	 * Sets the content of the SWT {@link clipboard} with the given objects.
	 */
	private void setNativeContentObjects(List<EObject> objects) {
		final Map<Transfer, Object> nativeFormat = toTransferObjects(objects);
		final int size = nativeFormat.size();
		if (size > 0) {
			final Object[] data = nativeFormat.values().toArray(new Object[size]);
			final Transfer[] dataTypes = nativeFormat.keySet().toArray(new Transfer[size]);

			final Clipboard cb = new Clipboard(Display.getCurrent());
			try {
				cb.setContents(data, dataTypes);
			} finally {
				cb.dispose();
			}
		}
	}

	/**
	 * @returns currently the {@link URI} content as {@link UriTransfer},
	 *          {@link TextTransfer}, {@link FileTransfer}, and Eclipse
	 *          {@link ResourceTransfer}.
	 */
	private synchronized Map<Transfer, Object> toTransferObjects(List<EObject> objects) {
		final Map<Transfer, Object> empty = Collections.emptyMap();
		final int size = objects.size();
		if (size == 0) {
			return empty;
		}

		final List<String> uriStrings = new ArrayList<String>(size);
		final List<IResource> files = new ArrayList<IResource>(size);
		final List<String> filePaths = new ArrayList<String>(size);
		for (int i = 0; i < size; i++) {
			final EObject o = objects.get(i);
			uriStrings.add(EcoreUtil.getURI(o).toString());
			IFile file = null;
			if (isSoleContent(o)) {
				file = GraphitiUiInternal.getEmfService().getFile(o);
			} else { 
				file = (IFile) Platform.getAdapterManager().getAdapter(o, IFile.class);
			}
			
			if (file != null && file.exists() && !files.contains(file)) {
				files.add(file);
				filePaths.add(file.getLocation().toOSString());
			}
		}
		final Map<Transfer, Object> result = new HashMap<Transfer, Object>(7);
		final UriTransferData data = new UriTransferData(uriStrings);
		ISelection localSelection = new StructuredSelection(objects);
		LocalSelectionTransfer.getTransfer().setSelection(localSelection);
		result.put(LocalSelectionTransfer.getTransfer(), new Object());
		result.put(UriTransfer.getInstance(), data);
		if (!filePaths.isEmpty()) {
			result.put(FileTransfer.getInstance(), filePaths.toArray(new String[filePaths.size()]));
			// Resource Transfer resides in org.eclipse.ui.ide. We need to
			// support an RCP scenario without having this plug-in installed.
			try {
				Transfer resourceTransfer = ReflectionUtil.getResourceTransfer();
				if (resourceTransfer != null)
					result.put(resourceTransfer, files.toArray(new IResource[files.size()]));
			} catch (Exception e) {
				T.racer().debug(e.getMessage());
			}
		}
		result.put(TextTransfer.getInstance(), toExtendedString(objects));
		return result;
	}

	private boolean isSoleContent(final EObject o) {
		Resource res = o.eResource();
		return (res != null && res.getContents().size() == 1);
	}

	private static List<String> getNativeContent() {
		final Clipboard cb = new Clipboard(Display.getCurrent());
		try {
			final UriTransferData contents = (UriTransferData) cb.getContents(UriTransfer.getInstance());
			if (contents != null) {
				return contents.getUriStrings();
			}
			return Collections.emptyList();
		} finally {
			cb.dispose();
		}
	}

	private String toExtendedString(List<EObject> objects) {
		final StringBuilder result = new StringBuilder();
		for (int i = 0; i < objects.size(); i++) {
			final EObject o = objects.get(i);
			GraphitiUiInternal.getEmfService().toString(o, result);
			if (i < objects.size() - 1) {
				result.append(UriTransferData.LINE_SEP);
			}
		}
		return result.toString();
	}

	@Override
	public String toString() {
		if (!(getContentAsStringList().size() > 0)) {
			return EMPTY_TOSTRING_PLACEHOLDER;
		}
		final List<String> content = getContentAsStringList();
		final String[] strings = content.toArray(new String[content.size()]);
		final StringBuilder b = new StringBuilder();
		for (int i = 0; i < strings.length; i++) {
			final String s = strings[i];
			b.append(s);
			if (i < strings.length - 1) {
				b.append(UriTransferData.LINE_SEP);
			}
		}
		return b.toString();
	}

	/**
	 * @return whether the SWT {@link Clipboard} can be accessed at all and in
	 *         the current thread
	 */
	private synchronized boolean canUseNative() {
		final boolean result = canUseUI();
		if (!result) {
			throw new IllegalStateException("ModelClipboard must be called from UI thread."); //$NON-NLS-1$
		}
		return result;
	}

	/**
	 * @return whether Ui may be raised
	 */
	private static boolean canUseUI() {
		return Display.getCurrent() != null;
	}

	private final class CopyCommand extends RecordingCommand {
		private final EObject parent;
		private final EObject[] srcObjectsFinal;
		private final Collection<EObject>[] copyResults;

		private CopyCommand(TransactionalEditingDomain domain, EObject parent, EObject[] srcObjectsFinal, Collection<EObject>[] copyResults) {
			super(domain);
			this.parent = parent;
			this.srcObjectsFinal = srcObjectsFinal;
			this.copyResults = copyResults;
		}

		@Override
		public String getLabel() {
			return Messages.ModelClipBoardPasteAction_0_xfld;
		}

		@Override
		protected void doExecute() {
			// actual copy
			final Collection<EObject> copyResult = deepCopy(this.srcObjectsFinal);
			// Process along the root elements only, avoid the effect of a child
			// element to appear before its parent could be handled.
			final Map<EObject, EObject> targetRootElements = getTargetRootElements(copyResult, this.srcObjectsFinal);
			final Set<EObject> targetElements = targetRootElements.keySet();

			final EObject[] elements = targetElements.toArray(new EObject[targetElements.size()]);
			if (this.parent != null) {
				addToCompositeParent(this.parent, elements, null);
			}
			this.copyResults[0] = copyResult;
		}
	}
}