//------------------------------------------------------------------------------
// 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.library.edit.process.command;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.emf.common.command.Command;
import org.eclipse.emf.edit.command.CopyCommand;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.epf.library.edit.LibraryEditResources;
import org.eclipse.epf.library.edit.util.Messenger;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.ProcessPackage;
import org.eclipse.epf.uma.UmaFactory;
import org.eclipse.epf.uma.edit.domain.TraceableAdapterFactoryEditingDomain;
/**
* AddCommand for activity
*
* @author Phong Nguyen Le - Sep 16, 2005
* @since 1.0
* @see
*/
public class ActivityAddCommand extends ProcessElementAddCommand {
private List procPackages;
/**
* @param command
*/
public ActivityAddCommand(Command command) {
super(command);
}
private Map getCopyToOriginalMap() {
EditingDomain ed = addCommand.getDomain();
if (ed instanceof TraceableAdapterFactoryEditingDomain) {
return ((TraceableAdapterFactoryEditingDomain) ed)
.getCopyToOriginalMap();
}
return null;
}
private void copyProcessPackages() {
if (procPackages == null) {
if (hasCopyToOriginalMap()) {
boolean showWarning = false;
procPackages = new ArrayList();
ArrayList<Activity> copiedActivities = new ArrayList();
// check first element of addCommand.getCollection()
// if it's a key in the CopyToOriginalMap, we are pasting and
// may need to warn the user
// if it's not a key in the CopyToOriginalMap, then we are
// probably adding a new element
if (addCommand.getCollection() != null
&& addCommand.getCollection().size() > 0
&& getOriginal(addCommand.getCollection().toArray()[0]) != null) {
for (Iterator iter = addCommand.getCollection().iterator(); iter
.hasNext();) {
Object element = iter.next();
if (element instanceof Activity) {
Activity orig = (Activity) getOriginal(element);
if (orig != null) {
if (orig.eContainer() != null) {
procPackages.add(orig.eContainer());
copiedActivities.add((Activity) element);
}
} else {
showWarning = true;
}
}
}
}
if (showWarning) {
Messenger.INSTANCE
.showWarning(
getLabel(),
LibraryEditResources.ActivityAddCommand_originalNotFoundWarning_msg);
}
if (!procPackages.isEmpty()) {
// copy the ProcessPackage of the original Activity to add
// it to the ProcessPackage
// of the target Activity.
//
// AdapterFactoryEditingDomain editingDomain = new
// AdapterFactoryEditingDomain(TngAdapterFactory.INSTANCE.getProcessComposedAdapterFactory()
// , new BasicCommandStack());
Command command = CopyCommand.create(
addCommand.getDomain(), procPackages);
try {
command.execute();
// Refresh the AddCommand.collection with new activity copies.
//
Collection collection = new ArrayList(addCommand.getCollection());
Collection elements = addCommand.getCollection();
elements.clear();
Collection col = command.getResult();
ArrayList<ProcessPackage> procPkgCopies = new ArrayList<ProcessPackage>(col);
// ArrayList<ProcessPackage> procPkgCopies = new ArrayList<ProcessPackage>(command.getResult());
for (Iterator iter = collection.iterator(); iter
.hasNext();) {
Object element = (Object) iter.next();
int index = copiedActivities.indexOf(element);
if(index != -1) {
ProcessPackage copy = procPkgCopies.get(index);
element = getActivityCopy(copy);
}
if(element != null) {
elements.add(element);
}
}
} finally {
if (command != null) {
command.dispose();
}
}
}
}
}
}
private Activity getActivityCopy(ProcessPackage copy) {
if (copy instanceof ProcessComponent) {
Activity actCopy = ((ProcessComponent) copy)
.getProcess();
// copy data from ProcessComponent to a new
// ProcessPackage
ProcessPackage pkgCopy = UmaFactory.eINSTANCE
.createProcessPackage();
pkgCopy.setName(actCopy.getName());
pkgCopy.getProcessElements().add(actCopy);
pkgCopy.getProcessElements().addAll(
copy.getProcessElements());
pkgCopy.getDiagrams()
.addAll(copy.getDiagrams());
pkgCopy.getChildPackages().addAll(
copy.getChildPackages());
return actCopy;
} else {
for (Iterator iterator = copy.getProcessElements().iterator(); iterator
.hasNext();) {
Object element = iterator.next();
if (element instanceof Activity) {
return (Activity) element;
}
}
}
return null;
}
/*
* (non-Javadoc)
*
* @see com.ibm.library.edit.command.MethodElementAddCommand#execute()
*/
public void execute() {
prepareAddList();
copyProcessPackages();
super.execute();
}
/**
* Checks if e is a child, direct or of act
*
* @param act
* @param e
* @return
*/
private static boolean isChildOf(Object parent, Object e) {
if (parent instanceof Activity) {
Activity act = (Activity) parent;
for (Iterator iter = act.getBreakdownElements().iterator(); iter
.hasNext();) {
Object child = iter.next();
if (e == child) {
return true;
}
if (isChildOf(child, e)) {
return true;
}
}
}
// else if(parent instanceof WorkProductDescriptor) {
// WorkProduct wp = ((WorkProductDescriptor)parent).getWorkProduct();
// if(wp instanceof Artifact) {
// if(e instanceof WorkProductDescriptor) {
// if(UmaUtil.isContainedBy(((WorkProductDescriptor)e).getWorkProduct(),
// wp)) {
// return true;
// }
// }
// }
// }
return false;
}
private static boolean isChildOf(Collection elements, Object e) {
for (Iterator iter = elements.iterator(); iter.hasNext();) {
if (isChildOf(iter.next(), e)) {
return true;
}
}
return false;
}
private boolean hasCopyToOriginalMap() {
EditingDomain ed = addCommand.getDomain();
if (ed instanceof TraceableAdapterFactoryEditingDomain) {
TraceableAdapterFactoryEditingDomain editingDomain = ((TraceableAdapterFactoryEditingDomain) ed);
return (editingDomain.getCopyToOriginalMap() != null &&
!editingDomain.getCopyToOriginalMap().isEmpty())
|| (editingDomain.getClipboardToOriginalMap() != null &&
!editingDomain.getClipboardToOriginalMap().isEmpty());
}
return false;
}
private Object getOriginal(Object copy) {
TraceableAdapterFactoryEditingDomain ed = (TraceableAdapterFactoryEditingDomain) addCommand.getDomain();
Object original = ed.getCopyToOriginalMap().get(copy);
if(original == null && ed.getClipboardToOriginalMap() != null) {
original = ed.getClipboardToOriginalMap().get(copy);
}
return original;
}
private void prepareAddList() {
// cleanup element list before adding it to the activity to avoid adding
// elements multiple times
//
if (hasCopyToOriginalMap()) {
ArrayList originals = new ArrayList();
Map originalToCopyMap = new HashMap();
for (Iterator iter = addCommand.getCollection().iterator(); iter
.hasNext();) {
Object element = iter.next();
Object original = getOriginal(element);
if (original != null) {
originals.add(original);
originalToCopyMap.put(original, element);
}
}
ArrayList removeList = new ArrayList();
// ArrayList addList = new ArrayList();
for (Iterator iter = originals.iterator(); iter.hasNext();) {
Object element = iter.next();
if (isChildOf(originals, element)) {
removeList.add(originalToCopyMap.get(element));
}
}
addCommand.getCollection().removeAll(removeList);
}
}
}