1.5/plugins/org.eclipse.epf.diagram.core/src/org/eclipse/epf/diagram/core/bridge/WorkBreakdownElementNodeAdapter.java - epf/org.eclipse.epf.composer - Git at Google

 //------------------------------------------------------------------------------
 // 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);
 //	}
 }
	//------------------------------------------------------------------------------
	// 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);
	// }
	}