//------------------------------------------------------------------------------
// 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
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
// 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.bridge;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.epf.diagram.model.Diagram;
import org.eclipse.epf.library.edit.command.IActionManager;
import org.eclipse.epf.library.edit.util.MethodElementPropertyHelper;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.MethodElementProperty;
import org.eclipse.epf.uma.ProcessPackage;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.WorkBreakdownElement;
import org.eclipse.epf.uma.WorkOrder;
import org.eclipse.epf.uma.util.UmaUtil;
import org.eclipse.uml2.uml.ActivityEdge;
import org.eclipse.uml2.uml.ActivityNode;
import org.eclipse.uml2.uml.ControlNode;
/**
* @author Phong Nguyen Le
*
* @since 1.2
*/
public class WorkBreakdownElementNodeAdapter extends NodeAdapter {
private class WorkBreakdownElementAdapter extends MethodElementAdapter {
protected Collection handleNotification(Notification msg) {
WorkOrder obj;
switch (msg.getFeatureID(WorkBreakdownElement.class)) {
case UmaPackage.WORK_BREAKDOWN_ELEMENT__LINK_TO_PREDECESSOR:
switch (msg.getEventType()) {
case Notification.ADD:
obj = (WorkOrder) msg.getNewValue();
if(isValid(obj)) {
addIncomingConnection(obj.getPred());
}
break;
case Notification.REMOVE:
obj = (WorkOrder) msg.getOldValue();
removeIncomingConnection(obj.getPred());
break;
case Notification.ADD_MANY:
Collection<?> collection = (Collection<?>) msg.getNewValue();
for (Iterator<?> iter = collection.iterator(); iter.hasNext();) {
obj = (WorkOrder) iter.next();
if(isValid(obj)) {
addIncomingConnection(obj.getPred());
}
}
break;
case Notification.REMOVE_MANY:
collection = (Collection) msg.getOldValue();
for (Iterator iter = collection.iterator(); iter.hasNext();) {
obj = (WorkOrder) iter.next();
removeIncomingConnection(obj.getPred());
}
break;
}
break;
case UmaPackage.WORK_BREAKDOWN_ELEMENT__SUPPRESSED:
switch (msg.getEventType()) {
case Notification.SET:
// Boolean b = (Boolean)msg.getNewValue();
// handleSuppressed(b.booleanValue());
break;
}
break;
default:
return super.handleNotification(msg);
}
return Collections.EMPTY_LIST;
}
}
/**
* @param e
*/
public WorkBreakdownElementNodeAdapter(MethodElement e) {
super(e);
}
/**
* Checks if the specified work order could be valid for the diagram to create
* new connection.
*
* @param wo
* @return
*/
private boolean isValid(WorkOrder wo) {
MethodElementProperty prop = MethodElementPropertyHelper.getProperty(wo, MethodElementPropertyHelper.WORK_ORDER__PREDECESSOR_IS_SIBLING);
if(prop != null) {
return true;
}
ActivityNode node = getNode();
org.eclipse.uml2.uml.Activity diagram = getDiagram();
ActivityDiagramAdapter diagramAdapter = (ActivityDiagramAdapter) BridgeHelper.getDiagramAdapter(diagram);
List<WorkBreakdownElement> localPredecessors = diagramAdapter.getLocalPredecessors(node);
return localPredecessors.contains(wo.getPred());
}
public void handleSuppressed(boolean b) {
if(b){
List incomings = getNode().getIncomings();
for (int i =0; i<incomings.size(); i++) {
Object obj = incomings.get(i);
ActivityEdge link = null;
if(obj != null ){
link = (ActivityEdge)obj;
}
if(link != null && link.getSource() != null){
NodeAdapter sourceNodeAdapter = BridgeHelper.getNodeAdapter(link.getSource());
boolean oldNotify1 = sourceNodeAdapter != null ? sourceNodeAdapter.notificationEnabled : false;
try {
if(sourceNodeAdapter != null) sourceNodeAdapter.notificationEnabled = false;
link.setTarget(null);
getNode().getIncomings().remove(link);
} finally {
if(sourceNodeAdapter != null) sourceNodeAdapter.notificationEnabled = oldNotify1;
}
}
}
List outGoings = getNode().getOutgoings();
for (int i =0; i<outGoings.size(); i++) {
Object obj = outGoings.get(i);
ActivityEdge link = null;
if(obj != null ){
link = (ActivityEdge)obj;
}
if(link != null && link.getTarget() != null){
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(link.getTarget());
boolean oldNotify1 = nodeAdapter != null ? nodeAdapter.notificationEnabled : false;
try {
if(nodeAdapter != null) nodeAdapter.notificationEnabled = false;
link.setSource(null);
getNode().getIncomings().remove(link);
} finally {
if(nodeAdapter != null) nodeAdapter.notificationEnabled = oldNotify1;
}
}
}
}else{
List nodes = getDiagram().getNodes();
for (Iterator iter = nodes.iterator(); iter.hasNext();) {
ActivityNode element = (ActivityNode) iter.next();
if(element != getNode() && target instanceof MethodElement){
MethodElement me = BridgeHelper.getMethodElement(element);
if(me != null){
addIncomingConnection(me);
addOutgoingConnection(me);
}
}
}
}
}
protected MethodElementAdapter createMethodElementAdapter() {
return new WorkBreakdownElementAdapter();
}
@Override
protected void removeFromUMA(ActivityEdge link, ActivityNode oldSource,
ActivityNode oldTarget) {
org.eclipse.epf.uma.Activity diagramActivity = (org.eclipse.epf.uma.Activity) BridgeHelper.getMethodElement(getDiagram());
ProcessPackage pkg = (ProcessPackage) diagramActivity.eContainer();
MethodElement targetElement = BridgeHelper.getMethodElement(oldTarget);
if (targetElement instanceof WorkBreakdownElement) {
// this is a direct link
// remove WorkOrder
//
WorkBreakdownElement succ = (WorkBreakdownElement) targetElement;
if(diagramActivity != succ.getSuperActivities()) {
Object sourceElement = BridgeHelper.getMethodElement(oldSource);
if(sourceElement instanceof WorkBreakdownElement) {
WorkBreakdownElement pred = (WorkBreakdownElement) sourceElement;
WorkOrder order = ProcessUtil.findWorkOrder(diagramActivity, succ, pred);
if(order != null) {
getActionManager().doAction(IActionManager.REMOVE, pkg,
UmaPackage.Literals.PROCESS_PACKAGE__PROCESS_ELEMENTS, order, -1);
}
}
}
else {
NodeAdapter targetNodeAdapter = BridgeHelper.getNodeAdapter(oldTarget);
boolean notify = targetNodeAdapter != null ? targetNodeAdapter.notificationEnabled : false;
try {
if(targetNodeAdapter != null) {
targetNodeAdapter.notificationEnabled = false;
}
if (BridgeHelper.canRemoveAllPreds(link, oldSource,
oldTarget)) {
Object pred = BridgeHelper.getMethodElement(oldSource);
if(pred instanceof WorkBreakdownElement) {
WorkBreakdownElement e = (WorkBreakdownElement) BridgeHelper.getMethodElement(oldTarget);
Collection<WorkOrder> workOrders = UmaUtil.findWorkOrder(e, (WorkBreakdownElement) pred, true);
if(!workOrders.isEmpty()) {
getActionManager().doAction(IActionManager.REMOVE_MANY, e,
UmaPackage.Literals.WORK_BREAKDOWN_ELEMENT__LINK_TO_PREDECESSOR, workOrders, -1);
}
}
}
} finally {
if(targetNodeAdapter != null) {
targetNodeAdapter.notificationEnabled = notify;
}
}
}
} else if(oldTarget instanceof ControlNode && BridgeHelper.isSynchBar(oldTarget)) {
// get all the WorkBreakdownElementNodes that this synch bar is
// coming to and
// remove the WorkOrders with this WorkBreakdownElementNode's
// activity as predecessor from them
//
Collection<ActivityNode> actNodes = new ArrayList<ActivityNode>();
BridgeHelper.getSuccessorNodes(actNodes, oldTarget);
Object pred = BridgeHelper.getMethodElement(oldSource);
for (ActivityNode node : actNodes) {
WorkBreakdownElement e = (WorkBreakdownElement) BridgeHelper.getMethodElement(node);
if(diagramActivity == e.getSuperActivities()) {
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(node);
boolean notify = nodeAdapter != null ? nodeAdapter.notificationEnabled : false;
try {
if(nodeAdapter != null) {
nodeAdapter.notificationEnabled = false;
}
if (BridgeHelper.canRemoveAllPreds(link, oldSource, node)) {
WorkOrder wo;
while ((wo = UmaUtil.findWorkOrder(e, pred)) != null) {
getActionManager().doAction(IActionManager.REMOVE, e,
UmaPackage.Literals.WORK_BREAKDOWN_ELEMENT__LINK_TO_PREDECESSOR, wo, -1);
}
}
} finally {
if(nodeAdapter != null) {
nodeAdapter.notificationEnabled = notify;
}
}
}
else {
if(pred instanceof WorkBreakdownElement) {
// remove custom work order if there is any
//
WorkOrder wo = ProcessUtil.findWorkOrder(diagramActivity, e, (WorkBreakdownElement) pred);
if(wo != null) {
getActionManager().doAction(IActionManager.REMOVE, pkg,
UmaPackage.Literals.PROCESS_PACKAGE__PROCESS_ELEMENTS, wo, -1);
}
}
}
}
}
}
protected boolean addToUMA(final ActivityEdge link) {
if (!super.addToUMA(link))
return false;
MethodElement e = BridgeHelper.getMethodElement(link.getSource());
Activity diagramActivity = (Activity) BridgeHelper.getMethodElement(getDiagram());
ProcessPackage pkg = (ProcessPackage) diagramActivity.eContainer();
if (e instanceof WorkBreakdownElement) {
// this is a direct link
// add new WorkOrder object to UMA
//
WorkBreakdownElement succ = (WorkBreakdownElement) BridgeHelper.getMethodElement(link.getTarget());
WorkBreakdownElement pred = (WorkBreakdownElement) e;
WorkOrder order = addWorkOrder(link.getTarget(), succ, link.getSource(), pred, diagramActivity, link);
// set the WorkOrder as the element of the link's edge
// BridgeHelper.setSemanticModel(link, order);
}
else if (BridgeHelper.isSynchBar(link.getSource())) {
// get all WorkBreakdownElementNodes that are comming to this
// join node, both directly and indirectly
// and create work orders with their activity as predecessor
//
// Predecessor should be created only in case of
// Syncronization Bar, not for DecisionPoint.
// TODO: review
Collection actNodes = new ArrayList();
// Get the collection incoming connection of syncbar
// excluding decisionpoint incoming connection
BridgeHelper.getSyncBarSourceNodes(link.getSource(), actNodes);
WorkBreakdownElement succ = (WorkBreakdownElement) BridgeHelper.getMethodElement(link.getTarget());
for (Iterator<?> iter = actNodes.iterator(); iter.hasNext();) {
ActivityNode node = (ActivityNode) iter.next();
WorkBreakdownElement pred = (WorkBreakdownElement) BridgeHelper.getMethodElement(node);
addWorkOrder(link.getTarget(), succ, node, pred, diagramActivity, null);
}
}
return true;
}
protected ActivityEdge addIncomingConnection(MethodElement source) {
ActivityEdge link = super.addIncomingConnection(source);
if (link == null)
return link;
WorkOrder workOrder = UmaUtil.findWorkOrder(
(WorkBreakdownElement) getElement(), source);
BridgeHelper.setSemanticModel(link, workOrder);
return link;
}
protected ActivityEdge addOutgoingConnection(MethodElement target) {
ActivityEdge link = super.addOutgoingConnection(target);
WorkOrder workOrder = UmaUtil.findWorkOrder(
(WorkBreakdownElement) target, getElement());
BridgeHelper.setSemanticModel(link, workOrder);
return link;
}
protected boolean removeIncomingConnection(MethodElement source) {
// look for the incoming connection with source as linked object of the
// source node
//
for (ActivityEdge link : getNode().getIncomings()) {
if (link.getSource() != null
&& BridgeHelper.getMethodElement(link.getSource()) == source) {
// disable internal notification of the source node
//
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(link.getSource());
boolean oldNotify = nodeAdapter != null ? nodeAdapter.notificationEnabled : false;
try {
if(nodeAdapter != null) nodeAdapter.notificationEnabled = false;
link.setSource(null);
} finally {
if(nodeAdapter != null) nodeAdapter.notificationEnabled = oldNotify;
}
link.setTarget(null);
BridgeHelper.setSemanticModel(link, null);
getDiagram().getEdges().remove(link);
return true;
}
}
return false;
}
// @Override
// protected void handleNotification(Notification msg) {
// switch(msg.getFeatureID(ActivityParameterNode.class)) {
// case UMLPackage.ACTIVITY_PARAMETER_NODE__EANNOTATIONS:
// switch(msg.getEventType()) {
// case Notification.ADD:
// ActivityParameterNode node = (ActivityParameterNode) msg.getNotifier();
// String type = BridgeHelper.getType(node);
// MethodElement e = BridgeHelper.getMethodElement(node);
// if(e instanceof BreakdownElement &&
// type != null && !type.equals(BridgeHelper.getType(e))) {
// // replace the currently linked method element with the right one
// //
// EClass rightType = BridgeHelper.getType(type);
// if(rightType != null) {
// Object rightElement = UmaFactory.eINSTANCE.create(rightType);
// List list = ((BreakdownElement)e).getSuperActivities().getBreakdownElements();
// list.set(list.indexOf(e), rightElement);
// return;
// }
//
// }
// }
// }
//
// super.handleNotification(msg);
// }
}