//------------------------------------------------------------------------------
// 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.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.eclipse.emf.common.command.AbstractCommand;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
import org.eclipse.emf.edit.provider.ItemProviderAdapter;
import org.eclipse.epf.library.edit.TngAdapterFactory;
import org.eclipse.epf.library.edit.command.IResourceAwareCommand;
import org.eclipse.epf.library.edit.util.DescriptorPropUtil;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.edit.util.WbePropUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.TaskDescriptor;
import org.eclipse.epf.uma.WorkBreakdownElement;
/**
* Command to move up the element in breakdown structure
*
* @author Shilpa Toraskar
* @since 1.0
*/
public class MoveUpCommand extends AbstractCommand implements
IResourceAwareCommand {
private Activity activity;
private Collection modifiedResources;
private int elementLocation = 0;
private int transferLocation = 0;
private Object elementObj;
private Collection eClasses;
private boolean adjacent = false;
private Map<WorkBreakdownElement, WorkBreakdownElement> globalPresentedAfterMap = new HashMap<WorkBreakdownElement, WorkBreakdownElement>();
/**
*
*/
public MoveUpCommand(Activity activity, Object elementObj,
Collection eClasses) {
super();
this.activity = activity;
this.elementObj = elementObj;
this.eClasses = eClasses;
this.modifiedResources = new HashSet();
if (activity.eResource() != null) {
modifiedResources.add(activity.eResource());
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.Command#execute()
*/
public void execute() {
if (elementObj instanceof WorkBreakdownElement) {
boolean completelyDone = handleWbeGlobalMove(activity,
(WorkBreakdownElement) elementObj, true, globalPresentedAfterMap);
if (completelyDone) {
return;
}
}
List allElements = activity.getBreakdownElements();
for (int i = 0; i < allElements.size(); i++) {
Object obj = allElements.get(i);
if (obj.equals(elementObj)) {
elementLocation = i;
break;
}
}
for (int i = elementLocation - 1; i >= 0; i--) {
Object obj = allElements.get(i);
if (TngUtil.isEClassInstanceOf(eClasses, obj)) {
transferLocation = i;
break;
}
}
BreakdownElement prev = (BreakdownElement) allElements.get(transferLocation);
if(prev.getPresentedAfter() == elementObj) {
adjacent = true;
}
redo();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.emf.common.command.Command#redo()
*/
public void redo() {
if(adjacent) {
// swap "presented-after" element
//
BreakdownElement prev = (BreakdownElement) activity.getBreakdownElements().get(transferLocation);
BreakdownElement e = (BreakdownElement) elementObj;
prev.setPresentedAfter(e.getPresentedAfter());
e.setPresentedAfter(prev);
}
((EList) activity.getBreakdownElements()).move(transferLocation,
elementLocation);
}
//return true if move is completely done - no need to do local move
//return false if move is partially done - still need to do local move
public static boolean handleWbeGlobalMove(Activity act, WorkBreakdownElement wbe, boolean up,
Map<WorkBreakdownElement, WorkBreakdownElement> globalPresentedAfterMap ) {
if (wbe instanceof TaskDescriptor
&& DescriptorPropUtil.getDesciptorPropUtil().getGreenParent(
(TaskDescriptor) wbe) != null) {
return true; //don't move for green customizing child
}
AdapterFactory aFactory = TngAdapterFactory.INSTANCE
.getWBS_ComposedAdapterFactory();
ItemProviderAdapter adapter = (ItemProviderAdapter) aFactory.adapt(
act, ITreeItemContentProvider.class);
Collection<?> children = adapter.getChildren(act);
if (! (children instanceof List)) {
return false;
}
WbePropUtil propUtil = WbePropUtil.getWbePropUtil();
boolean completelyDone = false;
List<?> childList = (List<?>) children;
Set<BreakdownElement> localSet = new HashSet<BreakdownElement>();
for (BreakdownElement be : act.getBreakdownElements()) {
if (be instanceof WorkBreakdownElement) {
if (be instanceof TaskDescriptor) {
if (DescriptorPropUtil.getDesciptorPropUtil()
.getGreenParent((TaskDescriptor) be) != null) {
continue;
}
}
WorkBreakdownElement w = (WorkBreakdownElement) be;
localSet.add(w);
globalPresentedAfterMap.put(w, propUtil.getGlobalPresentedAfter(w));
}
}
if (localSet.isEmpty()) {
return false;
}
WorkBreakdownElement globalPresentedAfter = act;
for (int i = 0; i < childList.size(); i++) {
Object child = childList.get(i);
if (child == wbe) {
Object newPrev = null;
if (up) {
if (i == 0) {
break;
}
newPrev = i == 1 ? act : TngUtil.unwrap(childList.get(i - 2));
Object prevItem = childList.get(i - 1);
Object nextItem = i + 1 < childList.size() ? childList
.get(i + 1) : null;
if (localSet.contains(prevItem)) {
propUtil.setGlobalPresentedAfter(
(WorkBreakdownElement) prevItem, wbe);
} else {
completelyDone = true;
}
if (nextItem != null && localSet.contains(nextItem)) {
WorkBreakdownElement nextWbe = (WorkBreakdownElement) nextItem;
prevItem = TngUtil.unwrap(prevItem);
if (prevItem instanceof WorkBreakdownElement) {
propUtil.setGlobalPresentedAfter(nextWbe,
(WorkBreakdownElement) prevItem);
} else {
propUtil.setGlobalPresentedAfter(nextWbe, null);
}
}
} else {
if (i == childList.size() - 1) {
break;
}
Object prevItem = i - 1 >= 0 ? childList.get(i - 1) : act;
newPrev = childList.get(i + 1);
if (localSet.contains(newPrev)) {
prevItem = TngUtil.unwrap(prevItem);
if (prevItem instanceof WorkBreakdownElement) {
propUtil.setGlobalPresentedAfter(
(WorkBreakdownElement) newPrev,
(WorkBreakdownElement) prevItem);
} else {
propUtil.setGlobalPresentedAfter(
(WorkBreakdownElement) newPrev, null);
}
} else {
completelyDone = true;
newPrev = TngUtil.unwrap(newPrev);
}
Object newNextItem = i + 2 < childList.size() ? childList
.get(i + 2) : null;
if (localSet.contains(newNextItem)) {
propUtil.setGlobalPresentedAfter((WorkBreakdownElement) newNextItem, wbe);
}
}
if (newPrev instanceof WorkBreakdownElement) {
globalPresentedAfter = (WorkBreakdownElement) newPrev;
}
break;
}
}
propUtil.setGlobalPresentedAfter(wbe, globalPresentedAfter);
if (! act.getBreakdownElements().isEmpty()) {
((EList) act.getBreakdownElements()).move(0, 0); //hmm ... cause notifying UI refresh
}
return completelyDone;
}
public void undo() {
((EList) activity.getBreakdownElements()).move(elementLocation,
transferLocation);
if(adjacent) {
// restore "presented-after" element
//
BreakdownElement prev = (BreakdownElement) activity.getBreakdownElements().get(transferLocation);
BreakdownElement e = (BreakdownElement) elementObj;
e.setPresentedAfter(prev.getPresentedAfter());
prev.setPresentedAfter(e);
}
WbePropUtil propUtil = WbePropUtil.getWbePropUtil();
if (!globalPresentedAfterMap.isEmpty()) {
for (Map.Entry<WorkBreakdownElement, WorkBreakdownElement> entry : globalPresentedAfterMap
.entrySet()) {
propUtil.setGlobalPresentedAfter(entry.getKey(), entry.getValue());
}
}
}
protected boolean prepare() {
return true;
}
public Collection getModifiedResources() {
return modifiedResources;
}
}