| //------------------------------------------------------------------------------ |
| // 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); |
| } |
| |
| } |
