//------------------------------------------------------------------------------
// 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.HashSet;
import java.util.Iterator;
import java.util.List;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.AdapterFactory;
import org.eclipse.emf.edit.provider.ITreeItemContentProvider;
import org.eclipse.emf.transaction.RollbackException;
import org.eclipse.epf.diagram.model.util.IAdapterFactoryFilter;
import org.eclipse.epf.library.edit.TngAdapterFactory;
import org.eclipse.epf.library.edit.command.IActionManager;
import org.eclipse.epf.library.edit.process.ActivityWrapperItemProvider;
import org.eclipse.epf.library.edit.process.BSActivityItemProvider;
import org.eclipse.epf.library.edit.process.BreakdownElementWrapperItemProvider;
import org.eclipse.epf.library.edit.process.IBSItemProvider;
import org.eclipse.epf.library.edit.util.ConfigurableComposedAdapterFactory;
import org.eclipse.epf.library.edit.util.DescriptorPropUtil;
import org.eclipse.epf.library.edit.util.PredecessorList;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.Descriptor;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.Milestone;
import org.eclipse.epf.uma.TaskDescriptor;
import org.eclipse.epf.uma.UmaFactory;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.VariabilityElement;
import org.eclipse.epf.uma.WorkBreakdownElement;
import org.eclipse.epf.uma.WorkOrder;
import org.eclipse.gmf.runtime.notation.Edge;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.uml2.uml.ActivityEdge;
import org.eclipse.uml2.uml.ActivityNode;
import org.eclipse.uml2.uml.ActivityParameterNode;
import org.eclipse.uml2.uml.ControlNode;
import org.eclipse.uml2.uml.StructuredActivityNode;
import org.eclipse.uml2.uml.UMLFactory;
/**
* @author Phong Nguyen Le
* @author Shilpa Toraskar
*
* @since 1.2
*/
public class ActivityDiagramAdapter extends DiagramAdapter {
public ActivityDiagramAdapter(BreakdownElementWrapperItemProvider wrapper) {
super(wrapper);
}
/**
* @param e
*/
public ActivityDiagramAdapter(Activity e) {
super(e);
}
protected ActivityNode addNode(Collection nodes, Object obj) {
if (obj instanceof Activity) {
Activity act = (Activity) obj;
VariabilityElement base = act.getVariabilityBasedOnElement();
if (base != null) {
// find existing node for base and link it to the activity
//
org.eclipse.uml2.uml.Activity diagram = getDiagram();
ActivityNode baseNode = BridgeHelper.findNode(diagram, base);
if (baseNode == null) {
baseNode = BridgeHelper.findNode(diagram, act);
}
if (baseNode != null) {
// disassociate with the base
//
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(baseNode);
if(nodeAdapter != null) {
nodeAdapter.dispose();
}
// associate base node with the activity
//
nodeAdapter = createNodeAdapter(act);
if(nodeAdapter != null) {
initializeNodeAdapter(nodeAdapter);
baseNode.eAdapters().add(nodeAdapter);
nodeAdapter.updateView();
// if(ProcessUtil.isExtendingOrLocallyContributing(act)) {
BridgeHelper.associate(baseNode, act);
if(BridgeHelper.isInherited(nodeAdapter.getView())){
BridgeHelper.unmarkInHerited(nodeAdapter.getView());
}
nodeAdapter.setTargetReadOnly(false);
// }
}
return null;
}
}
}
return super.addNode(nodes, obj);
}
protected NodeAdapter createNodeAdapter(MethodElement e) {
if(e instanceof WorkBreakdownElement) {
return new WorkBreakdownElementNodeAdapter(e);
}
return null;
}
protected void addToUmaModel(int position, ActivityNode addedNode) {
MethodElement e = BridgeHelper.getMethodElement(addedNode);
if(e == null) {
return;
}
Activity act = (Activity) getElement();
// translate ActivityNode index to Activity index
//
int i = toActivityIndex(position);
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(addedNode);
boolean notify = nodeAdapter.notificationEnabled;
try {
nodeAdapter.notificationEnabled = false;
getActionManager().doAction(IActionManager.ADD, act, UmaPackage.Literals.ACTIVITY__BREAKDOWN_ELEMENTS, e, i);
BridgeHelper.addEAnnotation(addedNode, e);
}
finally {
nodeAdapter.notificationEnabled = notify;
}
super.addToUmaModel(position, addedNode);
}
private int toActivityIndex(int index) {
if (index == -1)
return index;
int size = getNodes().size();
int i = index + 1;
if (i == size)
return -1;
ActivityNode node = (ActivityNode) getNodes().get(i);
if (node == null)
return -1;
for (; !(BridgeHelper.getMethodElement(node) instanceof BreakdownElement) && i < size; i++) {
node = (ActivityNode) getNodes().get(i);
}
if (i == size)
return -1;
Activity act = (Activity) getElement();
return act.getBreakdownElements().indexOf(BridgeHelper.getMethodElement(node));
}
protected List getBreakdownElementTypes() {
return Collections.singletonList(WorkBreakdownElement.class);
}
/* (non-Javadoc)
* @see org.eclipse.epf.diagram.core.bridge.DiagramAdapter#newNode(org.eclipse.epf.uma.MethodElement)
*/
protected ActivityNode newNode(MethodElement e) {
ActivityNode node = null;
if(e instanceof Activity ) {
node = UMLFactory.eINSTANCE.createStructuredActivityNode();
}
else if(e instanceof TaskDescriptor || e instanceof Milestone) {
node = UMLFactory.eINSTANCE.createActivityParameterNode();
}
else if(e instanceof WorkBreakdownElement) {
node = UMLFactory.eINSTANCE.createStructuredActivityNode();
}
if(node != null) {
BridgeHelper.associate(node, e);
}
return node;
}
private boolean isValid(ActivityEdge link) {
if (link.getSource() == null || link.getTarget() == null
|| !getNodes().contains(link.getSource())
|| !getNodes().contains(link.getTarget())) {
return false;
}
return true;
}
private static boolean isValidWorkOrder(WorkOrder wo, Object pred) {
if (wo.getPred() == pred) {
return true;
}
if (pred instanceof Activity) {
Activity act = (Activity) pred;
// check if predecessor reference in the given work order is base of
// pred
//
for (VariabilityElement ve = act.getVariabilityBasedOnElement(); ve != null; ve = ve
.getVariabilityBasedOnElement()) {
if (ve == wo.getPred()) {
return true;
}
}
}
return false;
}
/**
* Checks if Node src can reach Node target as the first ActivityNode in the
* diagram
*
* @param predNode
* @param node
* @return
*/
private static boolean canReachAsFirstActivityNode(ActivityNode predNode, ActivityNode node) {
for (Iterator iter = predNode.getOutgoings().iterator(); iter
.hasNext();) {
ActivityEdge link = (ActivityEdge) iter.next();
if (link.getTarget() == node) {
return true;
}
if (link.getTarget() instanceof ControlNode
&& canReachAsFirstActivityNode(link.getTarget(), node)) {
return true;
}
}
return false;
}
protected List<WorkBreakdownElement> getLocalPredecessors(ActivityNode node) {
Activity diagramActivity = (Activity) BridgeHelper.getMethodElement(getDiagram());
AdapterFactory adapterFactory = getAdapterFactory();
ITreeItemContentProvider adapter = (ITreeItemContentProvider) adapterFactory.adapt(diagramActivity, ITreeItemContentProvider.class);
Collection<?> children = adapter.getChildren(diagramActivity);
return getLocalPredecessors(node, children);
}
private List<WorkBreakdownElement> getLocalPredecessors(ActivityNode node, Collection<?> activityChildren) {
MethodElement e = BridgeHelper.getMethodElement(node);
if(e instanceof WorkBreakdownElement) {
// find item provider
//
Object object = null;
for (Object child : activityChildren) {
if(e == TngUtil.unwrap(child)) {
object = child;
break;
}
}
if(object != null) {
Object ip = getAdapterFactory().adapt(object, ITreeItemContentProvider.class);
if(ip instanceof IBSItemProvider) {
Object parent = ((ITreeItemContentProvider) ip).getParent(object);
ArrayList<WorkBreakdownElement> preds = new ArrayList<WorkBreakdownElement>();
PredecessorList predList = ((IBSItemProvider) ip).getPredecessors();
for (Object predIp : predList) {
Object pred = TngUtil.unwrap(predIp);
if (ProcessUtil.isSynFree() && pred instanceof TaskDescriptor) {
DescriptorPropUtil propUtil = DescriptorPropUtil.getDesciptorPropUtil();
List<? extends Descriptor> childList = propUtil.getCustomizingChildren((TaskDescriptor) pred);
if (childList != null && ! childList.isEmpty()) {
boolean processed = false;
for (Descriptor des : childList) {
if (des.getSuperActivities() == parent) {
preds.add((WorkBreakdownElement) des);
processed = true;
break;
}
}
if (processed) {
continue;
}
}
}
// make sure that predecessors are sibling
//
if(((ITreeItemContentProvider) predIp).getParent(pred) == parent) {
if(pred instanceof WorkBreakdownElement) {
preds.add((WorkBreakdownElement) pred);
} else if (pred instanceof Adapter) {
pred = ((Adapter) pred).getTarget();
if(pred instanceof WorkBreakdownElement) {
preds.add((WorkBreakdownElement) pred);
}
}
} else if (ProcessUtil.isSynFree() && pred instanceof Adapter) {
pred = ((Adapter) pred).getTarget();
if (pred instanceof TaskDescriptor) {
TaskDescriptor td = (TaskDescriptor) pred;
if (td.getSuperActivities() == parent) {
preds.add(td);
}
}
}
}
return preds;
}
}
}
return Collections.emptyList();
}
AdapterFactory getAdapterFactory(){
AdapterFactory adapterFactory = null;
if (filter == null) {
adapterFactory = TngAdapterFactory.INSTANCE.getWBS_ComposedAdapterFactory();
} else if (filter instanceof IAdapterFactoryFilter) {
adapterFactory = (ConfigurableComposedAdapterFactory) ((IAdapterFactoryFilter) filter)
.getWBSAdapterFactory();
}
return adapterFactory;
}
@Override
protected void populateLinks(List<ActivityNode> selectedNodes) {
if(selectedNodes.isEmpty()) {
return;
}
super.populateLinks(selectedNodes);
// remove the invalid links
//
for (ActivityNode node : selectedNodes) {
WorkBreakdownElement wbe = null;
MethodElement me;
if ((me = BridgeHelper.getMethodElement(node)) instanceof WorkBreakdownElement) {
wbe = (WorkBreakdownElement) me;
}
ArrayList<ActivityEdge> linksToRemove = new ArrayList<ActivityEdge>();
linkListWalk: for (Iterator iterator = node
.getIncomings().iterator(); iterator.hasNext();) {
ActivityEdge link = (ActivityEdge) iterator.next();
if (!isValid(link)) {
linksToRemove.add(link);
}
if (wbe != null) {
// TODO: need revisit to check the valid connection from a
// ForkNode or JoinNode
//
if (link.getSource() != null && link.getSource() instanceof ControlNode)
continue linkListWalk;
boolean workOrderFound = false;
WorkOrder workOrder = (WorkOrder) BridgeHelper.getMethodElement(link);
if(workOrder == null) {
Object pred = BridgeHelper.getMethodElement(link.getSource());
find_WorkOrder: for (Iterator iterator1 = wbe
.getLinkToPredecessor().iterator(); iterator1
.hasNext();) {
WorkOrder wo = (WorkOrder) iterator1.next();
if (isValidWorkOrder(wo, pred)) {
workOrderFound = true;
break find_WorkOrder;
}
}
} else {
workOrderFound = true;
}
if (!workOrderFound) {
// invalid link, remove it
//
linksToRemove.add(link);
}
}
}
for (ActivityEdge link : linksToRemove) {
BridgeHelper.removeLink(link);
}
linksToRemove.clear();
for (Iterator iterator = node.getOutgoings().iterator(); iterator
.hasNext();) {
ActivityEdge link = (ActivityEdge) iterator.next();
if (!isValid(link)) {
linksToRemove.add(link);
}
}
for (Iterator iterator = linksToRemove.iterator(); iterator
.hasNext();) {
ActivityEdge link = (ActivityEdge) iterator.next();
BridgeHelper.removeLink(link);
}
linksToRemove.clear();
linksToRemove = null;
}
// Check the links of each ActivityNode
// set the WorkOrder to the link if needed
// add new link for those WorkOrders that still don't have the
// corresponding link
//
Activity diagramActivity = (Activity) BridgeHelper.getMethodElement(getDiagram());
AdapterFactory adapterFactory = getAdapterFactory();
ITreeItemContentProvider adapter = (ITreeItemContentProvider) adapterFactory.adapt(diagramActivity, ITreeItemContentProvider.class);
Collection<?> children = adapter.getChildren(diagramActivity);
for (ActivityNode node : selectedNodes) {
List<WorkBreakdownElement> preds = getLocalPredecessors(node, children);
// Iterate work orders and create links.
for (WorkBreakdownElement pred : preds) {
ActivityNode predNode = BridgeHelper.findNode(getDiagram(),
pred, true);
if (predNode != null) {
// check if there is a link for this work order
// already
//
boolean linkFound = false;
find_link: for (Iterator<?> iterator1 = node
.getIncomings().iterator(); iterator1
.hasNext();) {
ActivityEdge link = (ActivityEdge) iterator1.next();
if (link.getSource() == predNode) {
// link already exists
// check if work order is set to this link
//
linkFound = true;
// MethodElement me = BridgeHelper.getMethodElement(link);
// if (link != null) {
// BridgeHelper.setSemanticModel(
// link, workOrder);
// }
break find_link;
}
}
if (!linkFound) {
// check if this WorkOrder can be represented
// via links of TypedNodes
//
if (!canReachAsFirstActivityNode(predNode, node)) {
// add new link for this work order
//
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(node);
NodeAdapter predNodeAdapter = BridgeHelper.getNodeAdapter(predNode);
if(nodeAdapter != null && predNodeAdapter != null) {
boolean oldNotify = nodeAdapter.notificationEnabled;
boolean predNodeNotify = predNodeAdapter.notificationEnabled;
try {
nodeAdapter.notificationEnabled = false;
predNodeAdapter.notificationEnabled = false;
ActivityEdge edge = nodeAdapter.addIncomingConnection(pred);
if(BridgeHelper.isInherited(node)) {
// target node is inherited, must find the custom work order and associate it with the edge
//
WorkBreakdownElement inheritedChild = (WorkBreakdownElement) BridgeHelper.getMethodElement(node);
if(inheritedChild != null) {
WorkOrder wo = ProcessUtil.findWorkOrder(diagramActivity, inheritedChild, pred);
if(wo != null) {
BridgeHelper.associate(edge, wo);
}
}
}
} finally {
nodeAdapter.notificationEnabled = oldNotify;
predNodeAdapter.notificationEnabled = predNodeNotify;
}
}
}
}
}
}
}
cleanDuplicateLinks(selectedNodes);
}
private void cleanDuplicateLinks(List<ActivityNode> selectedNodes) {
List<ActivityEdge> duplicateLinks = new ArrayList<ActivityEdge>();
for (ActivityNode wbNode : selectedNodes) {
if(wbNode.getIncomings() != null){
findDuplicateLinks(duplicateLinks, wbNode.getIncomings());
}
if(wbNode.getOutgoings() !=null){
findDuplicateLinks(duplicateLinks, wbNode.getOutgoings());
}
}
for (ActivityEdge link : duplicateLinks) {
BridgeHelper.removeLink(link);
}
duplicateLinks.clear();
duplicateLinks = null;
}
private void findDuplicateLinks(List duplicateLinks, List links) {
for (int i = 0; i < links.size(); i++) {
ActivityEdge link = (ActivityEdge) links.get(i);
if(!duplicateLinks.contains(link)){
for (int j = i + 1; j < links.size(); j++) {
ActivityEdge link1 = (ActivityEdge) links.get(j);
if (link1.getSource() == link.getSource()
&& link1.getTarget() == link.getTarget()) {
duplicateLinks.add(link1);
}
}
}
}
}
protected Collection populateNodes() {
HashSet selectedNodes = new HashSet();
Collection children = getChildren();
// associate control nodes
//
selectedNodes.addAll(associateControlNodes(children));
// add WorkBreakdownElementNodes
//
selectedNodes.addAll(addElementNodes(children));
return selectedNodes;
}
@Override
protected void updateView(Collection<?> selectedNodes)
throws InterruptedException, RollbackException {
super.updateView(selectedNodes);
hideUnusedSyncBars();
}
protected void hideUnusedSyncBars() {
View diagram = getView();
for (Object child : diagram.getVisibleChildren()) {
View childView = (View) child;
// hide a sync bar that is not connected to any visible target node
// or source node, which is associated with a work breakdown element
//
if(childView.getElement() instanceof ControlNode &&
BridgeHelper.isSynchBar((ActivityNode) childView.getElement()) &&
!isConnectedToVisibleWBENode(childView)) {
childView.setVisible(false);
}
}
}
private static boolean isConnectedToVisibleWBENode(View view) {
// check source nodes
//
for(Object object : view.getTargetEdges()) {
View connectedView = ((Edge) object).getSource();
// if(connectedView != null && connectedView.isVisible() &&
// connectedView.getElement() instanceof ActivityNode &&
// BridgeHelper.getMethodElement(connectedView) instanceof WorkBreakdownElement) {
// return true;
// }
if(connectedView != null && connectedView.isVisible() &&
connectedView.getElement() instanceof ActivityNode ) {
return true;
}
}
// check target nodes
//
for(Object object : view.getSourceEdges()) {
View connectedView = ((Edge) object).getTarget();
// if(connectedView != null && connectedView.isVisible() &&
// connectedView.getElement() instanceof ActivityNode &&
// BridgeHelper.getMethodElement(connectedView) instanceof WorkBreakdownElement) {
// return true;
// }
if(connectedView != null && connectedView.isVisible() &&
connectedView.getElement() instanceof ActivityNode) {
return true;
}
}
return false;
}
private List<? extends ControlNode> associateControlNodes(Collection<?> methodElements) {
List<ControlNode> ctrlNodes = new ArrayList<ControlNode>();
for (Iterator<?> iter = getDiagram().getNodes().iterator(); iter.hasNext();) {
ActivityNode node = (ActivityNode) iter.next();
if(node instanceof ControlNode) {
if(addNodeAdapterTo(node) != null) {
ctrlNodes.add((ControlNode) node);
}
}
}
return ctrlNodes;
}
/**
* Adds element nodes for the specified method elements if they don't exist yet.
*
* @param methodElements
*/
private List addElementNodes(Collection methodElements) {
ArrayList nodes = new ArrayList();
ArrayList newNodes = new ArrayList();
for (Iterator iter = methodElements.iterator(); iter.hasNext();) {
Object e = iter.next();
Object child = TngUtil.unwrap(e);
if (child instanceof WorkBreakdownElement) {
ActivityNode node = BridgeHelper.findNode(getDiagram(), child);
if(node == null) {
node = toNode((MethodElement) child);
newNodes.add(node);
}
else {
// synchronize name with linked element
//
String name = BridgeHelper.getNodeName((MethodElement) child);
if(!name.equals(node.getName())) {
node.setName(name);
}
addNodeAdapterTo(node);
}
nodes.add(node);
if (e instanceof BreakdownElementWrapperItemProvider && !isTargetReadOnly()) {
BreakdownElementWrapperItemProvider wrapper = ((BreakdownElementWrapperItemProvider) e);
if (wrapper.isReadOnly()) {
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(node);
nodeAdapter.wrapper = wrapper;
// readOnly attribute is still needed
// after introduction of wrapper.
// For example, we can have a node adapter for a read-only base activity
// without supplying wrapper for this base activity.
//
nodeAdapter.basicSetTargetReadOnly(true);
}
}
}
}
getNodes().addAll(newNodes);
return nodes;
}
/**
* Moved code from getChildren. getAdapter() will return Adapter,
* which will allow us to find itemprovider for the children.
*
* @return
*/
private ITreeItemContentProvider getAdapter(){
ITreeItemContentProvider adapter = null;
if (wrapper != null) {
adapter = wrapper;
} else {
adapter = (ITreeItemContentProvider) getAdapterFactory().adapt(
getElement(), ITreeItemContentProvider.class);
}
return adapter;
}
public Collection getChildren() {
ITreeItemContentProvider adapter = getAdapter();
if (adapter != null) {
//Turn off the VariabilityInfo for the activity diagram.
Object obj = null;
boolean enableVariabilityInfo = false;
if(adapter instanceof ActivityWrapperItemProvider){
obj = ((ActivityWrapperItemProvider)adapter).getDelegatingItemProvider();
}
if(adapter instanceof BSActivityItemProvider){
obj = adapter;
}
if(obj instanceof BSActivityItemProvider){
enableVariabilityInfo = ((BSActivityItemProvider)obj).isEnableVariabilityInfo();
((BSActivityItemProvider)obj).setEnableVariabilityInfo(false);
}
// end of variability info
// return adapter.getChildren(getObject());
// commented above line, For diagrams - rollup should be false, for
// handling rollup state below code.
List children = new ArrayList();
extractChildren(adapter, getElement(), children);
// reset variabilityinfo status back
if(obj instanceof BSActivityItemProvider){
((BSActivityItemProvider)obj).setEnableVariabilityInfo(enableVariabilityInfo);
}
return children;
} else {
return Collections.EMPTY_LIST;
}
}
protected boolean removeNode(Object obj) {
if (obj instanceof Activity) {
Activity act = (Activity) obj;
VariabilityElement base = act.getVariabilityBasedOnElement();
if (base != null) {
org.eclipse.uml2.uml.Activity diagram = getDiagram();
// find existing node for the old activity and relink it to its
// base
//
ActivityNode node = BridgeHelper.findNode(diagram, act);
if(node == null) {
node = BridgeHelper.findNode(diagram, base);
}
if (node != null) {
// disassociate with the old activity
//
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(node);
if(nodeAdapter != null) {
nodeAdapter.dispose();
}
// associate node with the base activity
//
nodeAdapter = createNodeAdapter(base);
if(nodeAdapter != null) {
initializeNodeAdapter(nodeAdapter);
nodeAdapter.basicSetTargetReadOnly(true);
node.eAdapters().add(nodeAdapter);
nodeAdapter.updateView();
if(!BridgeHelper.isInherited(nodeAdapter.getView())){
BridgeHelper.markInherited(nodeAdapter.getView());
}
}
return false;
}
}
}
return super.removeNode(obj);
}
protected NodeAdapter addNodeAdapterTo(ActivityNode node) {
NodeAdapter adapter = BridgeHelper.getNodeAdapter(node);
if(adapter != null) {
return adapter;
}
if(node instanceof ControlNode) {
adapter = new ControlNodeAdapter();
}
else {
MethodElement e = BridgeHelper.getMethodElement(node);
if(e == null) {
if(node instanceof StructuredActivityNode) {
String type = BridgeHelper.getType((StructuredActivityNode)node);
if (BridgeHelper.UMA_PHASE.equals(type)) {
e = UmaFactory.eINSTANCE.createPhase();
}
else if (BridgeHelper.UMA_ITERATION.equals(type)) {
e = UmaFactory.eINSTANCE.createIteration();
}
else {
e = UmaFactory.eINSTANCE.createActivity();
}
}
else if(node instanceof ActivityParameterNode) {
String type = BridgeHelper.getType((ActivityParameterNode)node);
if(BridgeHelper.UMA_MILESTONE.equals(type)) {
e = UmaFactory.eINSTANCE.createMilestone();
}
else {
e = UmaFactory.eINSTANCE.createTaskDescriptor();
}
}
}
if(e != null) {
adapter = new WorkBreakdownElementNodeAdapter(e);
}
}
if(adapter != null) {
initializeNodeAdapter(adapter);
node.eAdapters().add(adapter);
return adapter;
}
return null;
}
private ActivityNode reassociateBaseNode(Activity act) {
VariabilityElement base = act.getVariabilityBasedOnElement();
if (base != null) {
// find existing node for base and link it to the activity
//
org.eclipse.uml2.uml.Activity diagram = getDiagram();
ActivityNode baseNode = BridgeHelper.findNode(diagram, base);
if (baseNode == null) {
baseNode = BridgeHelper.findNode(diagram, act);
}
if (baseNode != null) {
// disassociate with the base
//
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(baseNode);
if(nodeAdapter != null) {
nodeAdapter.dispose();
}
// associate base node with the activity
//
nodeAdapter = createNodeAdapter(act);
if(nodeAdapter != null) {
initializeNodeAdapter(nodeAdapter);
baseNode.eAdapters().add(nodeAdapter);
nodeAdapter.updateView();
// if(ProcessUtil.isExtendingOrLocallyContributing(act)) {
BridgeHelper.associate(baseNode, act);
if(BridgeHelper.isInherited(nodeAdapter.getView())){
BridgeHelper.unmarkInHerited(nodeAdapter.getView());
}
nodeAdapter.setTargetReadOnly(false);
// }
}
return baseNode;
}
}
return null;
}
@Override
protected void replaceNode(Object oldElement, Object newElement) {
if(newElement instanceof MethodElement) {
// find existing node for old element and link it to the new element
//
org.eclipse.uml2.uml.Activity diagram = getDiagram();
ActivityNode oldNode = BridgeHelper.findNode(diagram, oldElement);
if (oldNode != null) {
// disassociate with the old element
//
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(oldNode);
if(nodeAdapter != null) {
nodeAdapter.dispose();
}
// associate base node with the new element
//
MethodElement e = (MethodElement) newElement;
nodeAdapter = createNodeAdapter(e);
if(nodeAdapter != null) {
initializeNodeAdapter(nodeAdapter);
oldNode.eAdapters().add(nodeAdapter);
nodeAdapter.updateView();
BridgeHelper.associate(oldNode, e);
}
}
}
}
}