deprecated_plugins/org.eclipse.epf.diagramming/src/org/eclipse/epf/diagramming/base/commands/CopyDiagramCommand.java

//------------------------------------------------------------------------------
// 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.diagramming.base.commands;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.eclipse.emf.common.command.AbstractCommand;
import org.eclipse.emf.ecore.EModelElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.transaction.Transaction;
import org.eclipse.emf.transaction.impl.InternalTransactionalEditingDomain;
import org.eclipse.epf.common.CommonPlugin;
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.model.NamedNode;
import org.eclipse.epf.diagram.model.NodeContainer;
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.StructuredActivityNode;

/**
 * 
 * It does copy the diagram for the activity
 * 
 * @author Shilpa Toraskar
 * @since 1.2
 */
public class CopyDiagramCommand extends AbstractCommand implements
		IResourceAwareCommand {

	private Collection elements;

	private Map copyToOriginalMap;

	private Collection<Diagram> copiedElements;

	private static final boolean DEBUG = DiagramCorePlugin.getDefault()
			.isDebugging();

	private Process targetProcess;

	/**
	 * 
	 */
	public CopyDiagramCommand(Collection elements, Map copyToOriginalMap,
			 Process targetProcess) {
		this.elements = elements;
		this.copyToOriginalMap = copyToOriginalMap;
		this.targetProcess = targetProcess;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.epf.library.edit.command.IResourceAwareCommand#getModifiedResources()
	 */
	public Collection getModifiedResources() {
		if (copiedElements == null || copiedElements.isEmpty()) {
			// command is not executed yet
			return Collections.EMPTY_LIST;
		}
		HashSet<Object> modifiedResources = new HashSet<Object>();

		for (Iterator iter = copiedElements.iterator(); iter.hasNext();) {
			Diagram diagram = (Diagram) iter.next();
			modifiedResources.add(diagram.eResource());
		}

		if (modifiedResources.isEmpty())
			return null;
		return modifiedResources;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.emf.common.command.Command#execute()
	 */
	public void execute() {
		redo();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.emf.common.command.Command#redo()
	 */
	public void redo() {
		if (copiedElements == null) {
			copiedElements = new ArrayList<Diagram>();
		} else {
			copiedElements.clear();
		}

		DiagramManager mgr = DiagramManager.getInstance(targetProcess);
		InternalTransactionalEditingDomain domain = mgr.getEditingDomain();
		try {
			for (Iterator iter = elements.iterator(); iter.hasNext();) {
				Object e = (Object) iter.next();
				Object orig = copyToOriginalMap.get(e);
				if (orig != null && orig instanceof Activity && e != null
						&& e instanceof Activity) {
					Activity copyActivity = (Activity) e;
					Activity origActivity = (Activity) orig;

					Collection diagrams = DiagramHelper
							.getDiagrams(origActivity);
					if (diagrams != null && !diagrams.isEmpty()) {
						for (Iterator itor = diagrams.iterator(); itor
								.hasNext();) {
							Diagram diagram = (Diagram) itor.next();
							if (diagram != null) {
								// copy the diagram
								Diagram diagramCopy = (Diagram) DiagramHelper
										.copyDiagram(domain, diagram);

								// update children references
								updateReferences(diagramCopy);

								Transaction tx = domain.startTransaction(false,
										Collections.EMPTY_MAP);

								// associate with the activity
								int diagramType = DiagramHelper
										.getDiagramType(diagramCopy);
								mgr.associate(diagramCopy, diagramType,
										(Activity) copyActivity);

								tx.commit();

								copiedElements.add(diagramCopy);
							}
						}
					}
				}
			}

			// TODO - to be removed later...
//			for (Iterator itor = copiedElements.iterator(); itor.hasNext();) {
//				Diagram diagramCopy = (Diagram) itor.next();
//				diagramCopy.eResource().save(Collections.EMPTY_MAP);
//			}
		} catch (Exception ex) {
			CommonPlugin.getDefault().getLogger().logError(ex);
			if (DEBUG) {
				ex.printStackTrace();
			}
		} finally {

			mgr.release();
		}
	}

	/**
	 * Update eAnnotations references
	 * 
	 * @param copy
	 */
	public void updateReferences(Diagram copy) {
		int diagramType = DiagramHelper.getDiagramType(copy);
		for (Iterator itor = copy.getChildren().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(copyToOriginalMap, 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(copyToOriginalMap, 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(copyToOriginalMap, 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(copyToOriginalMap, me);
					if (mappedMethodElement != null) {
						namedNode
								.setLinkedElement((MethodElement) mappedMethodElement);
					}
				}
			}
		}
	}

	
	/**
	 * Get copied element from the map
	 * @param copiedMap
	 * @param element
	 * @return
	 */
	private Object getCopiedElement(Map copiedMap, Object element)
	{
		Set keys =  copiedMap.keySet();
		for (Iterator itor = keys.iterator(); itor.hasNext(); )
		{
			Object key = itor.next();
			Object value = copiedMap.get(key);
			if (value.equals(element))
				return key;
		}
		
		return 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() {
		DiagramManager mgr = DiagramManager.getInstance(targetProcess);

		if (copiedElements == null || copiedElements.isEmpty()) {
			try {
				for (Iterator iter = copiedElements.iterator(); iter.hasNext();) {
					Diagram diagram = (Diagram) iter.next();

					mgr.getResource().getContents()
							.remove(diagram.getElement());
					mgr.getResource().getContents().remove(diagram);
				}
				copiedElements.clear();
			} catch (Exception ex) {
				CommonPlugin.getDefault().getLogger().logError(ex);
				if (DEBUG) {
					ex.printStackTrace();
				}
			} finally {
				mgr.release();
			}
		}
	}
}