//------------------------------------------------------------------------------
// 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.emf.common.command.Command;
import org.eclipse.emf.common.command.CompoundCommand;
import org.eclipse.emf.common.util.AbstractTreeIterator;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.edit.command.AddCommand;
import org.eclipse.emf.edit.command.RemoveCommand;
import org.eclipse.emf.edit.command.CopyCommand.Helper;
import org.eclipse.emf.edit.domain.EditingDomain;
import org.eclipse.epf.common.CommonPlugin;
import org.eclipse.epf.diagram.core.DiagramCorePlugin;
import org.eclipse.epf.diagram.core.part.DiagramEditorInput;
import org.eclipse.epf.diagram.core.part.DiagramEditorInputProxy;
import org.eclipse.epf.library.LibraryServiceUtil;
import org.eclipse.epf.library.edit.command.DeleteMethodElementCommand;
import org.eclipse.epf.library.edit.command.INestedCommandProvider;
import org.eclipse.epf.library.edit.command.MethodElementAddCommand;
import org.eclipse.epf.library.edit.command.ResourceAwareCompoundCommand;
import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider;
import org.eclipse.epf.library.edit.process.command.ActivityDropCommand;
import org.eclipse.epf.library.edit.process.command.CopyHelper;
import org.eclipse.epf.library.edit.process.command.ProcessDeepCopyCommand;
import org.eclipse.epf.library.edit.ui.IActionTypeProvider;
import org.eclipse.epf.library.edit.util.ActivityHandler;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.services.ILibraryPersister;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.MethodConfiguration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodLibrary;
import org.eclipse.epf.uma.MethodPlugin;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessComponent;
import org.eclipse.epf.uma.ProcessPackage;
import org.eclipse.epf.uma.edit.domain.TraceableAdapterFactoryEditingDomain;
import org.eclipse.epf.uma.util.UmaUtil;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorReference;
import org.eclipse.ui.IWorkbenchPage;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PartInitException;
import org.eclipse.ui.PlatformUI;
/**
* @author Shilpa Toraskar
* @author Phong Nguyen Le
* @since 1.2
*/
public class NestedCommandProvider implements INestedCommandProvider {
private static final boolean DEBUG = DiagramCorePlugin.getDefault()
.isDebugging();
/*
* (non-Javadoc)
*
* @see org.eclipse.epf.library.edit.command.INestedCommandProvider#createNestedCommand(org.eclipse.emf.common.command.Command)
*/
public Command createNestedCommand(Command command) {
if (command instanceof ActivityDropCommand) {
ActivityDropCommand cmd = (ActivityDropCommand) command;
if (IActionTypeProvider.COPY == cmd.getType())
return createNestedCommandForCopy(cmd);
else if (IActionTypeProvider.DEEP_COPY == cmd.getType())
return createNestedCommandForDeepCopy(cmd);
}
else if (command instanceof ProcessDeepCopyCommand) {
ProcessDeepCopyCommand cmd = (ProcessDeepCopyCommand) command;
Process deepCopy = null;
Collection<?> result = cmd.getResult();
if(!result.isEmpty()) {
deepCopy = (Process) result.iterator().next();
}
if(deepCopy != null) {
Collection<Activity> deepCopies = new ArrayList<Activity>();
deepCopies.add(deepCopy);
return createNestedCommandForDeepCopy(deepCopies, cmd.getTargetProcess(),
cmd.getCopyHelper(), cmd.getMethodConfiguration(), true);
}
}
return null;
}
/**
* Create nested command for Drag & Drop Copy
*
* @param command
* @return
*/
private Command createNestedCommandForCopy(ActivityDropCommand command) {
Collection<Resource> modifiedResources = ((ActivityDropCommand) command).getModifiedResources();
if (modifiedResources != null && !modifiedResources.isEmpty()) {
CompoundCommand cmd = new ResourceAwareCompoundCommand(
CompoundCommand.MERGE_COMMAND_ALL);
Helper copiedHelper = command.getActivityHandler().getCopyHelper();
Activity targetActivity = command.getActivity();
Process targetProc = TngUtil.getOwningProcess(targetActivity);
if (targetProc != null) {
try {
cmd.append(new CopyDiagramCommand(copiedHelper.values(),
copiedHelper, targetProc));
} catch (Exception ex) {
CommonPlugin.getDefault().getLogger().logError(ex);
if (DEBUG) {
ex.printStackTrace();
}
} finally {
}
}
if (!cmd.isEmpty()) {
return cmd;
}
}
return null;
}
/**
* Created nested command for Drag and Drop Deep copy
*
* @param command
* @return
*/
private Command createNestedCommandForDeepCopy(ActivityDropCommand command) {
ActivityHandler activityHandler = ((ActivityDropCommand) command)
.getActivityHandler();
if (activityHandler != null
&& !activityHandler.getDeepCopies().isEmpty()) {
return createNestedCommandForDeepCopy(activityHandler
.getDeepCopies(), activityHandler.getTargetProcess(),
activityHandler.getDeepCopyHelper(), activityHandler.getDeepCopyConfig(), false);
}
return null;
}
private Command createNestedCommandForDeepCopy(
Collection<Activity> deepCopies, final Process targetProc,
CopyHelper copyHelper, MethodConfiguration config,
boolean saveDiagram) {
CompoundCommand cmd;
if (saveDiagram) {
cmd = new ResourceAwareCompoundCommand(
CompoundCommand.MERGE_COMMAND_ALL) {
@Override
public void execute() {
super.execute();
// save diagram file
//
if (org.eclipse.epf.diagram.core.services.DiagramManager
.hasDiagramManager(targetProc)) {
org.eclipse.epf.diagram.core.services.DiagramManager mgr = org.eclipse.epf.diagram.core.services.DiagramManager
.getInstance(targetProc, this);
ILibraryPersister.FailSafeMethodLibraryPersister persister = LibraryServiceUtil
.getPersisterFor(targetProc.eResource())
.getFailSafePersister();
try {
Resource resource = mgr.getResource();
persister.save(resource);
persister.commit();
} catch (Exception e) {
DiagramCorePlugin.getDefault().getLogger()
.logError(e);
try {
persister.rollback();
} catch (Exception ex) {
DiagramCorePlugin.getDefault().getLogger()
.logError(ex);
}
} finally {
mgr.removeConsumer(this);
}
}
}
};
} else {
cmd = new ResourceAwareCompoundCommand(
CompoundCommand.MERGE_COMMAND_ALL);
}
for (Activity copyAct : deepCopies) {
Activity origAct = (Activity) copyHelper.getOriginal(copyAct);
Process srcProc = TngUtil.getOwningProcess(origAct);
Map<Activity, Activity> copyToOriginalMap = new HashMap<Activity, Activity>();
Iterator<BreakdownElement> copyTree = new AbstractTreeIterator<BreakdownElement>(
copyAct) {
@Override
protected Iterator<? extends BreakdownElement> getChildren(
Object object) {
if (object instanceof Activity) {
return ((Activity) object).getBreakdownElements()
.iterator();
}
return Collections.EMPTY_LIST.iterator();
}
};
while (copyTree.hasNext()) {
BreakdownElement e = copyTree.next();
if (e instanceof Activity) {
Object orig = copyHelper.getOriginal(e);
if (orig == null) {
System.out
.println("NestedCommandProvider.createNestedCommandForDeepCopy(): FATAL ERROR: could not find source activity of deep copy: " + e); //$NON-NLS-1$
} else {
copyToOriginalMap.put((Activity) e, (Activity) orig);
}
}
}
cmd.append(new CopyDiagramForDeepCopyCommand(copyToOriginalMap.keySet(),
copyToOriginalMap, srcProc, targetProc, copyHelper, config));
}
return !cmd.isEmpty() ? cmd : null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.epf.library.edit.command.INestedCommandProvider#createRelatedObjects(java.util.Collection,
* org.eclipse.emf.common.command.Command)
*/
public Command createRelatedObjects(Collection createdElements,
Command createCommand) {
CompoundCommand cmd = new ResourceAwareCompoundCommand(
CompoundCommand.MERGE_COMMAND_ALL);
if (createCommand instanceof MethodElementAddCommand) {
MethodElementAddCommand meCommand = ((MethodElementAddCommand) createCommand);
Command addCommand = meCommand.getCommand();
if (addCommand instanceof AddCommand) {
EditingDomain ed = ((AddCommand) addCommand).getDomain();
if (((AddCommand)addCommand).getOwner() instanceof ProcessPackage || ((AddCommand)addCommand).getOwner() instanceof MethodLibrary) {
if (ed instanceof TraceableAdapterFactoryEditingDomain) {
Map copyToOriginalMap = ((TraceableAdapterFactoryEditingDomain) ed)
.getCopyToOriginalMap();
if (!copyToOriginalMap.isEmpty()) {
Collection affects = meCommand.getAffectedObjects();
for (Iterator iter = affects.iterator(); iter
.hasNext();) {
MethodElement element = (MethodElement) iter
.next();
if (element instanceof MethodPlugin) {
for (Process proc : TngUtil
.getAllProcesses(((MethodPlugin) element))) {
cmd.append(new CopyDiagramCommand(
copyToOriginalMap.keySet(),
copyToOriginalMap, proc));
}
}
if (element instanceof ProcessComponent) {
cmd.append(new CopyDiagramCommand(
copyToOriginalMap.keySet(),
copyToOriginalMap,
((ProcessComponent) element)
.getProcess()));
}
}
}
}
} else {
// Copy/paste within the process editor
if (ed instanceof TraceableAdapterFactoryEditingDomain) {
Map originalToCopyMap = ((TraceableAdapterFactoryEditingDomain) ed)
.getOriginalToClipboardMap();
Map copyToOriginalMap = new HashMap();
Object owner = ((AddCommand) addCommand).getOwner();
Process targetProc = TngUtil.getOwningProcess(owner);
if (targetProc != null) {
for (Iterator iter = originalToCopyMap.keySet()
.iterator(); iter.hasNext();) {
Object key = iter.next();
Object val = originalToCopyMap.get(key);
copyToOriginalMap.put(val, key);
}
cmd.append(new CopyDiagramCommand(copyToOriginalMap.keySet(),
copyToOriginalMap, targetProc));
}
}
}
}
}
if (!cmd.isEmpty()) {
return cmd;
}
return null;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.epf.library.edit.command.INestedCommandProvider#removeRelatedObjects(java.util.Collection,
* org.eclipse.emf.common.command.Command)
*/
public Command removeRelatedObjects(Collection deletedElements,
Command deleteCommand) {
CompoundCommand cmd = new ResourceAwareCompoundCommand(
CompoundCommand.MERGE_COMMAND_ALL);
if(deleteCommand instanceof DeleteMethodElementCommand){
Command removeCommand = ((DeleteMethodElementCommand)deleteCommand).getCommand();
List<RemoveCommand> removeCommands = null;
if(removeCommand instanceof RemoveCommand){
removeCommands = Collections.singletonList((RemoveCommand)removeCommand);
}
else if(removeCommand instanceof CompoundCommand) {
removeCommands = new ArrayList<RemoveCommand>();
for (Command command : ((CompoundCommand)removeCommand).getCommandList()) {
if(command instanceof RemoveCommand) {
removeCommands.add((RemoveCommand) command);
}
}
}
if(removeCommands != null && !removeCommands.isEmpty()) {
Object owner = removeCommands.get(0).getOwner();
if(owner instanceof Activity) {
Process process = TngUtil.getOwningProcess((Activity)owner);
Collection<Activity> allElements = new HashSet<Activity>();
for (Iterator iter = deletedElements.iterator(); iter
.hasNext();) {
Object element = iter.next();
if (element instanceof Activity) {
Iterator iterator = new AbstractTreeIterator<Object>(element) {
private static final long serialVersionUID = 1L;
@Override
protected Iterator<? extends Object> getChildren(
Object object) {
if(object instanceof Activity) {
return ((Activity)object).getBreakdownElements().iterator();
}
else {
return Collections.emptyList().iterator();
}
}
};
while(iterator.hasNext()) {
Object e = iterator.next();
if(e instanceof Activity) {
allElements.add((Activity) e);
}
}
}
}
if(!allElements.isEmpty()){
cmd.append(new DeleteDiagramCommand(allElements, process));
}
for (RemoveCommand command : removeCommands) {
if(command.getOwner() instanceof Activity) {
DeleteDiagramNodeCommand deleteDiagramNodeCommand = new DeleteDiagramNodeCommand(
(Activity) command.getOwner(), command.getCollection());
if(deleteDiagramNodeCommand.canExecute()) {
cmd.append(deleteDiagramNodeCommand);
}
}
}
}
}
}
if(!deletedElements.isEmpty()){
for (Iterator iter = deletedElements.iterator(); iter.hasNext();) {
Object element = (Object) iter.next();
closeDiagramEditors(element);
}
}
if(!cmd.isEmpty()){
return cmd;
}
return null;
}
/**
* Closes Diagram Editors if the owning process is deleted.
* @param process
*/
private void closeDiagramEditors(Object e) {
IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if(activeWorkbenchWindow == null) {
return;
}
IWorkbenchPage workbenchPage = activeWorkbenchWindow.getActivePage();
IEditorReference[] editorReferences = workbenchPage
.getEditorReferences();
ArrayList<IEditorReference> editorsToClose = new ArrayList<IEditorReference>();
for (int i = 0; i < editorReferences.length; i++) {
IEditorReference editorRef = editorReferences[i];
IEditorInput editorInput;
try {
editorInput = editorRef.getEditorInput();
if (editorInput instanceof DiagramEditorInputProxy) {
DiagramEditorInput input = ((DiagramEditorInputProxy) editorInput)
.getDiagramEditorInput();
Object wrapper = input.getWrapper();
Process owningProcess = null;
if (wrapper != null) {
if (wrapper instanceof BreakdownElementWrapperItemProvider) {
owningProcess = TngUtil
.getOwningProcess(((BreakdownElementWrapperItemProvider) wrapper));
}
} else {
wrapper = input.getMethodElement();
if (wrapper instanceof BreakdownElement) {
owningProcess = TngUtil
.getOwningProcess(((BreakdownElement) wrapper));
}
}
if (owningProcess != null ) {
if (e == owningProcess)
editorsToClose.add(editorRef);
if ((owningProcess.eContainer() == null || UmaUtil
.isContainedBy(owningProcess, e))) {
editorsToClose.add(editorRef);
}
}
}
} catch (PartInitException ex) {
DiagramCorePlugin.getDefault().getLogger().logError(ex);
}
}
if(!editorsToClose.isEmpty()) {
IEditorReference[] refs = new IEditorReference[editorsToClose.size()];
editorsToClose.toArray(refs);
workbenchPage.closeEditors(refs, false);
}
}
}