//------------------------------------------------------------------------------
// 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 implementation
//------------------------------------------------------------------------------
package org.eclipse.epf.uma.edit.domain;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.common.command.CommandStack;
import org.eclipse.emf.common.command.CommandWrapper;
import org.eclipse.emf.common.command.StrictCompoundCommand;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.edit.command.CommandParameter;
import org.eclipse.emf.edit.command.CopyCommand;
import org.eclipse.emf.edit.command.PasteFromClipboardCommand;
import org.eclipse.emf.edit.command.CopyCommand.Helper;
import org.eclipse.emf.edit.domain.AdapterFactoryEditingDomain;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.epf.uma.MethodElement;
/**
* A traceable adapter factory editing domain used for copying method elements.
*
* @author Phong Nguyen Le
* @since 1.0
*/
public class TraceableAdapterFactoryEditingDomain extends
AdapterFactoryEditingDomain {
// Maps copied method elements to their original counterparts.
// Note: Copied elements are copies of the clipboard copies.
private HashMap<Object, Object> copyToOriginalMap = null;
// Maps original elements to their clipboard copies.
private Map<Object, Object> originalToClipboardMap = null;
private Map<EObject, EObject> clipboardToOriginalMap;
/**
* Creates a new instance.
*
* @param adapterFactory
* an adapter factory used to create the adapter to which calls
* are delegated
* @param commandStack
* a command stack
*/
public TraceableAdapterFactoryEditingDomain(AdapterFactory adapterFactory,
CommandStack commandStack) {
super(adapterFactory, commandStack);
}
/**
* Creates a new instance.
*
* @param adapterFactory
* an adapter factory used to create the adapter to which calls
* are delegated
* @param commandStack
* a command stack
* @param resourceToReadOnlyMap
* controls whether the domain is read only
*/
public TraceableAdapterFactoryEditingDomain(AdapterFactory adapterFactory,
CommandStack commandStack, Map resourceToReadOnlyMap) {
super(adapterFactory, commandStack, resourceToReadOnlyMap);
}
/**
* Creates a new instance.
*
* @param adapterFactory
* an adapter factory used to create the adapter to which calls
* are delegated
* @param commandStack
* a command stack
* @param resourceSet
* a resource set
*/
public TraceableAdapterFactoryEditingDomain(AdapterFactory adapterFactory,
CommandStack commandStack, ResourceSet resourceSet) {
super(adapterFactory, commandStack, resourceSet);
}
/**
* Returns a map containing the copied elements mapped to their original
* counterparts.
*
* @return a map containing the copied elements mapped to their original
* counterparts
*/
public Map<?, ?> getCopyToOriginalMap() {
if (copyToOriginalMap == null) {
copyToOriginalMap = new HashMap<Object, Object>();
}
return copyToOriginalMap;
}
/**
* Returns a map containing the original elements mapped to their copied
* counterparts on clipboard
*
* @return a map containing the original elements mapped to their copied
* counterparts
*/
public Map getOriginalToClipboardMap() {
if (originalToClipboardMap == null) {
originalToClipboardMap = new HashMap();
}
return originalToClipboardMap;
}
/**
* Used by the CreateCopyCommand. Adds infomation to construct maps that
* keep track of the original method elements and their copies.
*
* @param c
* a collection to store the mapping info
* @param copyHelper
* a helper class that is used to keep track of copied objects
* and their associated copies
*/
public void addCopyInfo(Collection c, Helper copyHelper) {
if (isNewCopy(c, copyHelper)) {
addNewCopy(c, copyHelper);
return;
} else {
chainCopy(c, copyHelper);
return;
}
}
/**
* Adds a new element that is being copied to the clipboard.
*/
private void addNewCopy(Collection c, Helper copyHelper) {
// this means we are copying the Collection c to the clipboard
if (originalToClipboardMap == null)
originalToClipboardMap = new HashMap();
if(clipboardToOriginalMap == null) {
clipboardToOriginalMap = new HashMap<EObject, EObject>();
}
Iterator iter = copyHelper.keySet().iterator();
while (iter.hasNext()) {
EObject key = (EObject) iter.next();
EObject value = (EObject) copyHelper.get(key);
originalToClipboardMap.put(key, value);
clipboardToOriginalMap.put(value, key);
}
}
/**
* Creates a map from the copied elements to their original counterparts.
*/
private void chainCopy(Collection c, Helper copyHelper) {
// chain the maps - change the copyToOriginalMap
if (originalToClipboardMap != null) {
if (copyToOriginalMap == null)
copyToOriginalMap = new HashMap();
Iterator iter = originalToClipboardMap.keySet().iterator();
while (iter.hasNext()) {
Object o2CKey = iter.next();
Object o2CValue = originalToClipboardMap.get(o2CKey);
Object copyValue = copyHelper.get(o2CValue);
if (copyValue == null) {
// error
continue;
}
if (o2CKey instanceof MethodElement)
copyToOriginalMap.put(copyValue, o2CKey);
}
}
}
private boolean isNewCopy(Collection c, Helper copyHelper) {
// originalToClipboardMap was set to null at start of copy command
if (originalToClipboardMap == null)
return true;
// iterate through copyHelper map, see if any copyHelper keys are o2C
// values, which means we are copying clipboard
Iterator iter = copyHelper.keySet().iterator();
while (iter.hasNext()) {
Object clipKey = iter.next();
if (!originalToClipboardMap.containsValue(clipKey))
return true;
}
return false;
}
/**
* Initializes the copy maps. It should be called within the copy action.
*/
public void resetCopyMaps() {
if (originalToClipboardMap != null) {
originalToClipboardMap.clear();
originalToClipboardMap = null;
}
if(clipboardToOriginalMap != null) {
clipboardToOriginalMap.clear();
clipboardToOriginalMap = null;
}
if (copyToOriginalMap != null) {
copyToOriginalMap.clear();
copyToOriginalMap = null;
}
}
public Map<EObject, EObject> getClipboardToOriginalMap() {
return clipboardToOriginalMap;
}
private Map<Object, Object> extenalMaintainedCopyMap;
public Map<Object, Object> getExtenalMaintainedCopyMap() {
return extenalMaintainedCopyMap;
}
public void setExtenalMaintainedCopyMap(
Map<Object, Object> extenalMaintainedCopyMap) {
this.extenalMaintainedCopyMap = extenalMaintainedCopyMap;
}
protected static class InternalPasteFromClipboardCommand extends PasteFromClipboardCommand {
public InternalPasteFromClipboardCommand(EditingDomain domain, Object owner, Object feature, int index, boolean optimize) {
super(domain, owner, feature, index, optimize);
}
@Override
protected boolean prepare()
{
// Create a strict compound command to do a copy and then add the result
//
command = new StrictCompoundCommand();
// Create a command to copy the clipboard.
//
final Command copyCommand = CopyCommand.create(domain, domain.getClipboard());
command.append(copyCommand);
// Create a proxy that will create an add command.
//
command.append
(new CommandWrapper()
{
protected Collection<Object> original;
protected Collection<Object> copy;
@Override
protected Command createCommand()
{
original = domain.getClipboard();
copy = new ArrayList<Object>(copyCommand.getResult());
// Use the original to do the add, but only if it's of the same type as the copy.
// This ensures that if there is conversion being done as part of the copy,
// as would be the case for a cross domain copy in the mapping framework,
// that we do actually use the converted instance.
//
if (original.size() == copy.size())
{
for (Iterator<Object> i = original.iterator(), j = copy.iterator(); i.hasNext(); )
{
Object originalObject = i.next();
Object copyObject = j.next();
if (originalObject.getClass() != copyObject.getClass())
{
original = null;
break;
}
}
}
Command addCommand = AddCommand.create(domain, owner, feature, copy, index);
return addCommand;
}
@Override
public void execute()
{
if (original != null)
{
domain.setClipboard(copy);
}
super.execute();
}
@Override
public void undo()
{
super.undo();
if (original != null)
{
domain.setClipboard(original);
}
}
@Override
public void redo()
{
if (original != null)
{
domain.setClipboard(copy);
}
super.redo();
}
});
boolean result;
if (optimize)
{
// This will determine canExecute as efficiently as possible.
//
result = optimizedCanExecute();
}
else
{
// This will actually execute the copy command in order to check if the add can execute.
//
result = command.canExecute();
}
return result;
}
}
public Command createCommand(Class commandClass, CommandParameter commandParameter) {
if (commandClass == PasteFromClipboardCommand.class) {
return new InternalPasteFromClipboardCommand(this, commandParameter
.getOwner(), commandParameter.getFeature(),
commandParameter.getIndex(), getOptimizeCopy());
}
return super.createCommand(commandClass, commandParameter);
}
}