//------------------------------------------------------------------------------
// Copyright (c) 2005, 2007 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.diagram.core.commands;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.core.commands.ExecutionException;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.emf.common.command.AbstractCommand;
import org.eclipse.emf.common.util.WrappedException;
import org.eclipse.emf.ecore.EModelElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.edit.command.CopyCommand.Helper;
import org.eclipse.emf.transaction.impl.InternalTransactionalEditingDomain;
import org.eclipse.epf.diagram.core.DiagramCorePlugin;
import org.eclipse.epf.diagram.core.bridge.BridgeHelper;
import org.eclipse.epf.diagram.core.services.DiagramHelper;
import org.eclipse.epf.diagram.core.services.DiagramManager;
import org.eclipse.epf.diagram.core.services.DiagramService;
import org.eclipse.epf.diagram.model.NamedNode;
import org.eclipse.epf.diagram.model.NodeContainer;
import org.eclipse.epf.diagram.model.util.TxUtil;
import org.eclipse.epf.library.edit.command.IResourceAwareCommand;
import org.eclipse.epf.library.edit.util.IDiagramManager;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.Process;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.Node;
import org.eclipse.uml2.uml.ActivityParameterNode;
import org.eclipse.uml2.uml.ActivityPartition;
import org.eclipse.uml2.uml.StructuredActivityNode;
/**
*
* It does copy the diagram for the activity
*
* @author Shilpa Toraskar
* @author Phong Nguyen Le
* @since 1.2
*/
public class CopyDiagramCommand extends AbstractCommand implements
IResourceAwareCommand {
private Collection<?> elements;
private Map<EObject, EObject> copyToOriginalMap;
private Collection<Diagram> copiedElements;
private static final boolean DEBUG = DiagramCorePlugin.getDefault()
.isDebugging();
private Process targetProcess;
private DiagramManager mgr;
private InternalTransactionalEditingDomain domain;
private Map<EObject, EObject> originalToCopyMap;
private CopyDiagramCommand(Collection<?> elements, Process targetProcess) {
this.elements = elements;
this.targetProcess = targetProcess;
// get diagram manager and domain
mgr = DiagramManager.getInstance(targetProcess, this);
domain = mgr.getEditingDomain();
}
public CopyDiagramCommand(Collection<?> elements, Helper copyHelper,
Process targetProcess) {
this(elements, targetProcess);
this.originalToCopyMap = copyHelper;
}
public CopyDiagramCommand(Collection<?> elements, Map<EObject, EObject> copyToOriginalMap,
Process targetProcess) {
this(elements, targetProcess);
this.copyToOriginalMap = copyToOriginalMap;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.Command#execute()
*/
public void execute() {
try {
TxUtil.runInTransaction(domain, new Runnable() {
public void run() {
doExecute();
}
});
} catch (ExecutionException e) {
DiagramCorePlugin.getDefault().getLogger().logError(e);
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.Command#redo()
*/
public void redo() {
execute();
}
protected Map<?, ?> getCopyToOriginalMap() {
if(copyToOriginalMap == null && originalToCopyMap != null) {
copyToOriginalMap = new HashMap<EObject, EObject>();
for (Map.Entry<EObject, EObject> entry : originalToCopyMap.entrySet()) {
copyToOriginalMap.put(entry.getValue(), entry.getKey());
}
}
return copyToOriginalMap;
}
private void doExecute() {
if (copiedElements == null) {
copiedElements = new ArrayList<Diagram>();
} else {
copiedElements.clear();
}
DiagramService diagramSvc = new DiagramService();
try {
for (Object e : elements) {
Object orig = getCopyToOriginalMap().get(e);
if (orig != null && orig instanceof Activity && e != null
&& e instanceof Activity) {
Activity copyActivity = (Activity) e;
Activity origActivity = (Activity) orig;
Collection<Diagram> diagrams = diagramSvc.getDiagrams(origActivity);
if (diagrams != null && !diagrams.isEmpty()) {
for (Diagram diagram : diagrams) {
if (diagram != null) {
// copy the diagram
Diagram diagramCopy = (Diagram) DiagramHelper
.copyDiagram(domain, diagram);
// update children references
updateReferences(diagramCopy);
// associate with the activity
int diagramType = DiagramHelper
.getDiagramType(diagramCopy);
mgr.associate(diagramCopy, diagramType,
(Activity) copyActivity);
copiedElements.add(diagramCopy);
}
}
}
}
}
} catch (Exception ex) {
DiagramCorePlugin.getDefault().getLogger().logError(ex);
if (DEBUG) {
ex.printStackTrace();
}
} finally {
diagramSvc.dispose();
}
}
/**
* Update eAnnotations references
*
* @param copy
*/
public void updateReferences(Diagram copy) {
int diagramType = DiagramHelper.getDiagramType(copy);
List<Object> children = new ArrayList<Object>();
// collect all children first e.g. for ActivityPartition
// we don't have partition into partition so just getting one level sub-children
// are enough for now.
for (Iterator<?> itor = copy.getChildren().iterator(); itor.hasNext();) {
Node node = (Node) itor.next();
EObject obj = node.getElement();
children.add(node);
if (obj instanceof ActivityPartition){
children.addAll(node.getChildren());
}
}
for (Iterator<?> itor = children.iterator(); itor.hasNext();) {
Node node = (Node) itor.next();
EObject obj = node.getElement();
if (diagramType == IDiagramManager.ACTIVITY_DIAGRAM) {
if (obj instanceof StructuredActivityNode
|| obj instanceof ActivityParameterNode) {
EModelElement modelElement = (EModelElement) obj;
MethodElement me = BridgeHelper
.getMethodElementFromAnnotation(modelElement,
targetProcess.eResource().getResourceSet());
Object mappedMethodElement = getCopiedElement(me);
if (mappedMethodElement != null) {
BridgeHelper.addEAnnotation(modelElement,
(MethodElement) mappedMethodElement);
}
}
} else if (diagramType == IDiagramManager.ACTIVITY_DETAIL_DIAGRAM) {
if (obj instanceof NodeContainer) {
NodeContainer nodeContainer = (NodeContainer) obj;
// do mapping for nodecontainer
MethodElement me = nodeContainer.getLinkedElement();
Object mappedMethodElement = getCopiedElement(me);
if (mappedMethodElement != null) {
nodeContainer
.setLinkedElement((MethodElement) mappedMethodElement);
}
// do mapping for its children
List<?> nodes = nodeContainer.getNodes();
for (int i = 0; i < nodes.size(); i++) {
NamedNode namedNode = (NamedNode) nodes.get(i);
me = namedNode.getLinkedElement();
mappedMethodElement = getCopiedElement(me);
if (mappedMethodElement != null) {
namedNode
.setLinkedElement((MethodElement) mappedMethodElement);
}
}
}
} else if (diagramType == IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM) {
if (obj instanceof NamedNode) {
NamedNode namedNode = (NamedNode) obj;
MethodElement me = namedNode.getLinkedElement();
Object mappedMethodElement = getCopiedElement(me);
if (mappedMethodElement != null) {
namedNode
.setLinkedElement((MethodElement) mappedMethodElement);
}
}
}
}
}
/**
* Get copied element from the map
*
* @param element
* @return
*/
private Object getCopiedElement(Object element) {
if(originalToCopyMap == null && copyToOriginalMap != null) {
originalToCopyMap = new HashMap<EObject, EObject>();
for (Map.Entry<EObject, EObject> entry : copyToOriginalMap.entrySet()) {
originalToCopyMap.put(entry.getValue(), entry.getKey());
}
}
return originalToCopyMap != null ? originalToCopyMap.get(element) : null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.AbstractCommand#prepare()
*/
protected boolean prepare() {
return true;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.AbstractCommand#undo()
*/
public void undo() {
if (!(copiedElements == null || copiedElements.isEmpty())) {
try {
TxUtil.runInTransaction(domain, new Runnable() {
public void run() {
try {
for (Diagram diagram : copiedElements) {
mgr.getResource().getContents()
.remove(diagram.getElement());
mgr.getResource().getContents().remove(diagram);
}
} catch (CoreException e) {
throw new WrappedException(e);
}
}
});
copiedElements.clear();
} catch (Exception ex) {
DiagramCorePlugin.getDefault().getLogger().logError(ex);
if (DEBUG) {
ex.printStackTrace();
}
}
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.epf.library.edit.command.IResourceAwareCommand#getModifiedResources()
*/
public Collection<Resource> getModifiedResources() {
if (copiedElements == null || copiedElements.isEmpty()) {
// command is not executed yet
return Collections.emptyList();
}
HashSet<Resource> modifiedResources = new HashSet<Resource>();
for (Diagram diagram : copiedElements) {
if(diagram != null && diagram.eResource() != null)
modifiedResources.add(diagram.eResource());
}
return modifiedResources;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.AbstractCommand#dispose()
*/
public void dispose() {
if (mgr != null)
mgr.removeConsumer(this);
super.dispose();
}
}