//------------------------------------------------------------------------------
// 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.text.MessageFormat;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EAnnotation;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.EModelElement;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.EcoreFactory;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.epf.diagram.core.DiagramCorePlugin;
import org.eclipse.epf.diagram.model.DiagramResources;
import org.eclipse.epf.diagram.model.LinkedObject;
import org.eclipse.epf.diagram.model.NamedNode;
import org.eclipse.epf.diagram.model.Node;
import org.eclipse.epf.library.edit.util.DescriptorPropUtil;
import org.eclipse.epf.library.edit.util.ProcessUtil;
import org.eclipse.epf.library.edit.util.Suppression;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.library.persistence.ILibraryResource;
import org.eclipse.epf.persistence.UnnormalizedURIException;
import org.eclipse.epf.uma.BreakdownElement;
import org.eclipse.epf.uma.DescribableElement;
import org.eclipse.epf.uma.Iteration;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.Milestone;
import org.eclipse.epf.uma.Phase;
import org.eclipse.epf.uma.Process;
import org.eclipse.epf.uma.ProcessElement;
import org.eclipse.epf.uma.ProcessPackage;
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.emf.type.core.IElementType;
import org.eclipse.gmf.runtime.notation.Diagram;
import org.eclipse.gmf.runtime.notation.View;
import org.eclipse.uml2.uml.Activity;
import org.eclipse.uml2.uml.ActivityEdge;
import org.eclipse.uml2.uml.ActivityNode;
import org.eclipse.uml2.uml.ActivityPartition;
import org.eclipse.uml2.uml.ControlNode;
import org.eclipse.uml2.uml.ForkNode;
import org.eclipse.uml2.uml.JoinNode;
/**
* @author Phong Nguyen Le
* @author Shilpa Toraskar
*
* @since 1.2
*/
public final class BridgeHelper {
public static final String UMA_ELEMENT = "uma_element"; //$NON-NLS-1$
public static final String UMA_URI = "uri"; //$NON-NLS-1$
public static final String UMA_TYPE = "type"; //$NON-NLS-1$
public static final String UMA_PHASE = "Phase"; //$NON-NLS-1$
public static final String UMA_ITERATION = "Iteration"; //$NON-NLS-1$
public static final String UMA_ACTIVITY = "Activity"; //$NON-NLS-1$
public static final String UMA_TASK_DESCRIPTOR = "Task"; //$NON-NLS-1$
public static final String UMA_MILESTONE = "Milestone"; //$NON-NLS-1$
public static final String ANNOTATION_INHERIRED = "inherited"; //$NON-NLS-1$
public static List<IElementType> elementTypes = new ArrayList<IElementType>();
public static Map<String, EClass> typeStringToEClass = new HashMap<String, EClass>();
private static final boolean DEBUG = DiagramCorePlugin.getDefault().isDebugging();
static {
typeStringToEClass.put(UMA_PHASE, UmaPackage.Literals.PHASE);
typeStringToEClass.put(UMA_ITERATION, UmaPackage.Literals.ITERATION);
typeStringToEClass.put(UMA_ACTIVITY, UmaPackage.Literals.ACTIVITY);
typeStringToEClass.put(UMA_TASK_DESCRIPTOR, UmaPackage.Literals.TASK_DESCRIPTOR);
typeStringToEClass.put(UMA_MILESTONE, UmaPackage.Literals.MILESTONE);
}
public static void setSemanticModel(ActivityEdge link, WorkOrder workOrder) {
// TODO Auto-generated method stub
}
public static boolean isReadOnly(View view) {
NodeAdapter nodeAdapter = BridgeHelper
.getNodeAdapter(view.getElement());
if(nodeAdapter != null) {
return nodeAdapter.isTargetReadOnly();
}
if(view.getElement() instanceof Node) {
return ((Node)view.getElement()).isReadOnly();
}
return false;
}
/**
* Gets the method element that the given view represents.
*
* @param node
* @return method element that the view is representing or <code>null</code>
* if the view does not represent any method element or the diagram
* of the view currently is not opened in a diagram editor.
*/
public static MethodElement getMethodElement(View view) {
return getMethodElement(view.getElement());
}
/**
* Gets the method element that the given diagram model object represents.
*
* @param modelObject
* @return method element that the model object is representing or <code>null</code>
* if the model object does not represent any method element or the diagram
* of the model object currently is not opened in a diagram editor.
*/
public static MethodElement getMethodElement(EObject modelObject) {
if(modelObject instanceof LinkedObject) {
return ((LinkedObject)modelObject).getLinkedElement();
}
else if(modelObject instanceof EModelElement) {
return getMethodElement((EModelElement) modelObject);
}
return null;
}
public static MethodElement getMethodElement(View view, org.eclipse.epf.uma.Activity owner) {
EObject modelObject = view.getElement();
if(modelObject instanceof LinkedObject) {
return ((LinkedObject)modelObject).getLinkedElement();
}
else if(modelObject instanceof EModelElement) {
Resource resource = owner.eResource();
if(resource != null && resource.getResourceSet() != null) {
return getMethodElementFromAnnotation((EModelElement) modelObject, resource.getResourceSet());
}
}
return null;
}
public static boolean isSuppressed(View view) {
EObject element = view.getElement();
if(element instanceof NamedNode) {
return ((NamedNode)element).isSuppressed();
}
else if(element instanceof EModelElement) {
NodeAdapter nodeAdapter = getNodeAdapter(element);
if(nodeAdapter != null) {
Object o = nodeAdapter.getWrapper();
if(o == null) {
o = nodeAdapter.getElement();
}
org.eclipse.epf.uma.Activity activity = (org.eclipse.epf.uma.Activity) getMethodElement(view.getDiagram());
Process proc = TngUtil.getOwningProcess(activity);
Suppression suppression = Suppression.getSuppression(proc);
return suppression.isSuppressed(o);
}
}
return false;
}
// public static Object getSemanticModel(View view) {
// EObject element = view.getElement();
// if(element instanceof EModelElement) {
// return getSemanticModelFromAnnotation(element, process, adapterFactory);
// }
// else if(element instanceof )
//
// }
// }
public static void removeLink(ActivityEdge link) {
// TODO: still need to disable notification before removing link???
Activity activity = link.getActivity();
ActivityNode sourceNode = link.getSource();
ActivityNode targetNode = link.getTarget();
boolean srcNotify = sourceNode != null ? sourceNode.eDeliver() : false;
boolean targetNotify = targetNode != null ? targetNode.eDeliver()
: false;
try {
if (sourceNode != null) {
sourceNode.eSetDeliver(false);
}
if (targetNode != null) {
targetNode.eSetDeliver(false);
}
link.setSource(null);
link.setTarget(null);
if(activity != null){
activity.getEdges().remove(link);
}
} finally {
if (sourceNode != null) {
sourceNode.eSetDeliver(srcNotify);
}
if (targetNode != null) {
targetNode.eSetDeliver(targetNotify);
}
}
}
/**
* Finds node whose linked object or one of its base is the given object
*
* @param container
* @param object
* @return
*/
public static ActivityNode findNode(Activity container, Object object,
boolean checkBase) {
if (container != null) {
for (Iterator iter = container.getNodes().iterator(); iter.hasNext();) {
ActivityNode node = (ActivityNode) iter.next();
MethodElement e = BridgeHelper.getMethodElement(node);
if (object == e) {
return node;
} else if (checkBase && e instanceof VariabilityElement) {
for (VariabilityElement ve = ((VariabilityElement) e)
.getVariabilityBasedOnElement(); ve != null; ve = ve
.getVariabilityBasedOnElement()) {
if (ve == object) {
return node;
}
}
}
}
}
return null;
}
public static boolean isSynchBar(ActivityNode node) {
return node instanceof ForkNode || node instanceof JoinNode;
}
/**
* Finds node whose linked object is the given object
*
* @return
*/
public static ActivityNode findNode(Activity container, Object object) {
for (Iterator iter = container.getNodes().iterator(); iter.hasNext();) {
ActivityNode node = (ActivityNode) iter.next();
MethodElement element = BridgeHelper.getMethodElement(node);
if (object == element) {
return node;
}
if (object instanceof TaskDescriptor) {
DescriptorPropUtil propUtil = DescriptorPropUtil
.getDesciptorPropUtil();
TaskDescriptor greenParent = (TaskDescriptor) propUtil
.getGreenParentDescriptor((TaskDescriptor) object);
while(greenParent != null) {
if (greenParent == element) {
return node;
}
greenParent = (TaskDescriptor) propUtil.getGreenParentDescriptor(greenParent);
}
}
}
return null;
}
public static URI getProxyURI(MethodElement e) {
Resource resource = e.eResource();
if (resource instanceof ILibraryResource) {
return ((ILibraryResource) resource).getProxyURI(e);
} else if (resource != null) {
return resource.getURI().appendFragment(e.getGuid());
}
return null;
}
/**
* Associates a {@link EModelElement} with a {@link MethodElement} by
* creating or updating the UMA_ELEMENT annotation of the given
* {@link EModelElement}.
*
* @param element
* @param me
* @return true if successful, false otherwise
* @see #addEAnnotation(EModelElement, MethodElement)
*/
public static boolean associate(EModelElement element, MethodElement me) {
EAnnotation annotation = addEAnnotation(element, me);
if(annotation != null) {
String type = getType(me);
if(type != null) {
annotation.getDetails().put(UMA_TYPE, type);
}
return true;
}
return false;
}
public static EClass getType(String type) {
return typeStringToEClass.get(type);
}
public static String getType(MethodElement me) {
if(me instanceof Phase) {
return UMA_PHASE;
}
else if(me instanceof Iteration) {
return UMA_ITERATION;
}
else if(me instanceof Milestone) {
return UMA_MILESTONE;
}
else if(me instanceof org.eclipse.epf.uma.Activity) {
return UMA_ACTIVITY;
}
else if(me instanceof TaskDescriptor) {
return UMA_TASK_DESCRIPTOR;
}
return null;
}
// /**
// * Creates or updates the UMA_ELEMENT annotation for the given
// * {@link EModelElement} with the given method element or its wrapper
// *
// * @param element
// * @param me
// * @return
// */
// public static EAnnotation addEAnnotation(EModelElement element, Object breakdownElementOrWrapper) {
// String uriStr = null;
// if(breakdownElementOrWrapper instanceof MethodElement) {
// URI uri = getProxyURI((MethodElement) breakdownElementOrWrapper);
// if(uri != null) {
// uriStr = uri.toString();
// }
// }
// else if(breakdownElementOrWrapper instanceof BreakdownElementWrapperItemProvider){
// uriStr = Suppression.getPath((BreakdownElementWrapperItemProvider) breakdownElementOrWrapper);
// }
// if(uriStr != null) {
// EAnnotation eAnnotation = element.getEAnnotation(UMA_ELEMENT);
// if (eAnnotation == null) {
// eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
// eAnnotation.setSource(UMA_ELEMENT);
// element.getEAnnotations().add(eAnnotation);
// }
// eAnnotation.getDetails().put(UMA_URI, uriStr);
// return eAnnotation;
// }
// return null;
// }
/**
* Creates or updates the UMA_ELEMENT annotation for the given
* {@link EModelElement} with the given method element
*
* @param element
* @param me
* @return
*/
public static EAnnotation addEAnnotation(EModelElement element,
MethodElement me) {
URI uri = getProxyURI(me);
if (uri != null) {
EAnnotation eAnnotation = element.getEAnnotation(UMA_ELEMENT);
if (eAnnotation == null) {
eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
eAnnotation.setSource(UMA_ELEMENT);
element.getEAnnotations().add(eAnnotation);
}
eAnnotation.getDetails().put(UMA_URI, uri.toString());
return eAnnotation;
}
return null;
}
private static Activity getActivity(EModelElement e) {
EObject o = e;
for(; o != null && !(o instanceof Activity); o = o.eContainer());
return (Activity) o;
}
// public static Object getSemanticModelFromAnnotation(EModelElement model, Process process, AdapterFactory adapterFactory) {
// EAnnotation eAnnotation = model.getEAnnotation(UMA_ELEMENT);
// if (eAnnotation != null) {
// String uriStr = (String) eAnnotation.getDetails().get(UMA_URI);
// if (uriStr != null) {
// URI uri = URI.createURI(uriStr);
// if(MultiFileURIConverter.SCHEME.equals(uri.scheme())) {
// EObject o = process.eResource().getResourceSet().getEObject(uri, false);
// if (o instanceof MethodElement) {
// return (MethodElement) o;
// } else {
// // TODO: log error
// System.err.println("Not a method element: " + o); //$NON-NLS-1$
// }
// }
// else {
// // must be a wrapper path
// //
// String[] guidPath = uri.segments();
// return Suppression.getSuppression(process).getObjectByPath(guidPath, adapterFactory);
// }
// }
// }
// return null;
// }
public static MethodElement getMethodElementFromAnnotation(EModelElement node, ResourceSet resourceSet) {
EAnnotation eAnnotation = node.getEAnnotation(UMA_ELEMENT);
try {
if (eAnnotation != null) {
String uri = (String) eAnnotation.getDetails().get(UMA_URI);
if (uri != null) {
EObject o = resourceSet.getEObject(
URI.createURI(uri), false);
if (o instanceof MethodElement) {
return (MethodElement) o;
} else {
if(DEBUG) {
System.err.println("Not a method element: " + o); //$NON-NLS-1$
}
}
}
}
} catch (Exception e) {
if (!(e instanceof UnnormalizedURIException)) {
DiagramCorePlugin.getDefault().getLogger().logError(e);
}
return null;
}
return null;
}
/**
* Gets the method element that the given diagram model object represents
* and stores the linkage info in its annotation.
*
* @param node
* the diagram model object
* @return method element that the model object is representing or
* <code>null</code> if the model object does not represent any
* method element or the diagram of the model object currently is
* not opened in a diagram editor.
*/
public static MethodElement getMethodElementFromAnnotation(EModelElement node) {
Activity diagram = getActivity(node);
if(diagram == null) {
return null;
}
NodeAdapter nodeAdapter = getNodeAdapter(diagram);
if(nodeAdapter == null || nodeAdapter.getElement() == null) {
return null;
}
Resource resource = nodeAdapter.getElement().eResource();
if (resource != null && resource.getResourceSet() != null) {
return getMethodElementFromAnnotation(node, resource.getResourceSet());
}
return null;
}
public static MethodElement getMethodElement(EModelElement node) {
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(node);
return nodeAdapter != null ? nodeAdapter.getElement()
: getMethodElementFromAnnotation(node);
}
public static NodeAdapter getNodeAdapter(EObject node) {
if (node != null) {
for (Iterator iter = node.eAdapters().iterator(); iter.hasNext();) {
Object adapter = (Object) iter.next();
if (adapter instanceof NodeAdapter) {
return (NodeAdapter) adapter;
}
}
}
return null;
}
public static DiagramAdapter getDiagramAdapter(EObject node) {
for (Iterator iter = node.eAdapters().iterator(); iter.hasNext();) {
Object adapter = (Object) iter.next();
if (adapter instanceof DiagramAdapter) {
return (DiagramAdapter) adapter;
}
}
return null;
}
/**
* Method to get the sources of SyncBar (ForkNode or JoinNode) inComming
* connections and if syncbar have incoming connection from decision point,
* and decision point have incomming connections (workbreaddown elemtns)
* collections will ignore all the incoming connection from decision point.
* @return
*/
public static void getSyncBarSourceNodes(ActivityNode node,
Collection actNodes) {
for (Iterator iter = node.getIncomings().iterator(); iter.hasNext();) {
ActivityEdge link = (ActivityEdge) iter.next();
ActivityNode source = link.getSource();
if (getMethodElement(source) instanceof WorkBreakdownElement) {
actNodes.add(source);
} else if (isSynchBar(source)) {
getSyncBarSourceNodes(source, actNodes);
}
}
}
/**
* Gets all nodes with the given type that are direct or indirect targets of
* the given node.
*
* @param actNodes
* @param node
* @param type
* the type of method element associated with the view
*/
public static void getTargetNodes(Collection actNodes, ActivityNode node,
Class type) {
if (node != null) {
for (Iterator iter = node.getOutgoings().iterator(); iter.hasNext();) {
ActivityEdge link = (ActivityEdge) iter.next();
ActivityNode target = link.getTarget();
if (type.isInstance(getMethodElement(target))) {
actNodes.add(target);
} else if (target instanceof ControlNode) {
getTargetNodes(actNodes, target, type);
}
}
}
}
public static void getSuccessorNodes(Collection<ActivityNode> actNodes, ActivityNode node) {
if (node != null) {
for (ActivityEdge link : node.getOutgoings()) {
ActivityNode target = link.getTarget();
if (getMethodElement(target) instanceof WorkBreakdownElement) {
actNodes.add(target);
} else if (isSynchBar(target)) {
getSuccessorNodes(actNodes, target);
}
}
}
}
public static void getPredecessorNodes(Collection<ActivityNode> actNodes, ActivityNode node) {
if (node != null) {
for (ActivityEdge link : node.getIncomings()) {
ActivityNode source = link.getSource();
if (getMethodElement(source) instanceof WorkBreakdownElement) {
actNodes.add(source);
} else if (isSynchBar(source)) {
getPredecessorNodes(actNodes, source);
}
}
}
}
/**
* Gets all nodes with the given type that are direct or indirect sources of
* the given node.
*
* @param actNodes
* @param node
* @param type
* the type of method element associated with the view
*/
public static void getSourceNodes(Collection actNodes, ActivityNode node,
Class type) {
if (node != null) {
for (Iterator iter = node.getIncomings().iterator(); iter.hasNext();) {
ActivityEdge link = (ActivityEdge) iter.next();
ActivityNode source = link.getSource();
if (type.isInstance(getMethodElement(source))) {
actNodes.add(source);
} else if (source instanceof ControlNode) {
getSourceNodes(actNodes, source, type);
}
}
}
}
/*
* Method to collect synchronization bar outgoing connection
* except any connection going to decision points.
*/
public static void getSyncBarTargetNodes(ActivityNode typedNode, Collection actNodes){
for (Iterator iter = typedNode.getOutgoings().iterator(); iter.hasNext();) {
ActivityEdge link = (ActivityEdge) iter.next();
ActivityNode target = link.getTarget();
if(BridgeHelper.getMethodElement(target) instanceof WorkBreakdownElement){
actNodes.add(target);
} else if (isSynchBar(target)) {
getSyncBarTargetNodes(target, actNodes);
}
}
}
/**
* Method to check before deleting a link. If duplicate predecessor exists
* in the legacy data, check if deleting link should remove all the
* predecessors or not by verifying if target or indirect target have direct
* or indirect links.
*/
public static boolean canRemoveAllPreds(ActivityEdge link, ActivityNode oldSource,
ActivityNode oldTarget) {
MethodElement targetElement = getMethodElement(oldTarget);
if (targetElement instanceof WorkBreakdownElement) {
List inlist = oldTarget.getIncomings();
for (Iterator itor = inlist.iterator(); itor.hasNext();) {
ActivityEdge incominglink = (ActivityEdge) itor.next();
// RATLC00384245 : Predecessor changes should be done only in
// case of Synchronization Bar.
if (isSynchBar(incominglink.getSource())) {
Collection col = new ArrayList();
getSourceNodes(col, incominglink.getSource(),
WorkBreakdownElement.class);
if (col.contains(oldSource)) {
return false;
}
} else if (incominglink.getSource() != null &&
getMethodElement(incominglink.getSource()) instanceof WorkBreakdownElement) {
if (incominglink.getSource().equals(oldSource))
return false;
}
}
}
return true;
}
public static void markInherited(EModelElement element) {
if(isInherited(element)) {
return;
}
EAnnotation eAnnotation = element.getEAnnotation(ANNOTATION_INHERIRED);
if (eAnnotation == null) {
eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
eAnnotation.setSource(ANNOTATION_INHERIRED);
element.getEAnnotations().add(eAnnotation);
}
}
public static void unmarkInHerited(EModelElement element) {
EAnnotation eAnnotation = element.getEAnnotation(ANNOTATION_INHERIRED);
if (eAnnotation != null) {
element.getEAnnotations().remove(eAnnotation);
}
}
public static Diagram copyDiagram(Diagram baseDiagram) {
Diagram copy = (Diagram) EcoreUtil.copy(baseDiagram);
// HACK:
// go thru the nodes of the diagram copy, if any node is a UI-only node
// (see TypedNode)
// save the GUID of the original one in its briefDescription to remember
// who is base.
//
// int size = copy.getContained().size();
// for (int i = 0; i < size; i++) {
// GraphNode gNode = (GraphNode) copy.getContained().get(i);
// if (GraphicalDataHelper.isUIGraphNode(gNode)) {
// gNode.setBriefDescription(((DiagramElement) baseDiagram
// .getContained().get(i)).getGuid());
// }
// }
List children = copy.getChildren();
int size = children.size();
for (int i = 0; i < size; i++) {
View view = (View) children.get(i);
markInherited(view);
}
return copy;
}
public static EList addEAnnotationDetail(EModelElement element, String detailName, String detailValue ) {
EAnnotation eAnnotation = element.getEAnnotation(UMA_ELEMENT);
if (eAnnotation == null) {
eAnnotation = EcoreFactory.eINSTANCE.createEAnnotation();
eAnnotation.setSource(UMA_ELEMENT);
// detail must be put before the new annotation can be added to the annotation list
// so any adapter that listen to change in the annotation list can get the details
// when it gets notified.
//
eAnnotation.getDetails().put(UMA_TYPE, detailValue);
element.getEAnnotations().add(eAnnotation);
}
else {
eAnnotation.getDetails().put(UMA_TYPE, detailValue);
}
return element.getEAnnotations();
}
/**
* Creates and/or adds the eAnnotation detail for type. {@link BridgeHelper.UMA_TYPE}
* @param element
* @param type
*/
public static EList addEAnnotationType(EModelElement element, String type) {
EList result = addEAnnotationDetail(element, UMA_TYPE, type);
if(element instanceof ActivityNode) {
ActivityNode node = (ActivityNode) element;
// ActivityParameterNode node = (ActivityParameterNode) element;
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 = getType(type);
if(rightType != null) {
BreakdownElement rightElement = (BreakdownElement) UmaFactory.eINSTANCE.create(rightType);
org.eclipse.epf.uma.Activity activity = ((BreakdownElement)e).getSuperActivities();
if(activity != null) {
List list = activity.getBreakdownElements();
list.set(list.indexOf(e), rightElement);
ProcessPackage pkg = (ProcessPackage) activity.eContainer();
if (pkg != null) {
pkg.getProcessElements().add(rightElement);
// Also set the rightElement to its own process package.
List childPkgs = pkg.getChildPackages();
if (!childPkgs.isEmpty()) {
for (Iterator iter = pkg.getChildPackages()
.iterator(); iter.hasNext();) {
ProcessPackage child = (ProcessPackage) iter
.next();
List<ProcessElement> pList = child
.getProcessElements();
if (!pList.isEmpty()) {
if (pList.contains(e)) {
pList.set(pList.indexOf(e),
rightElement);
}
}
}
}
}
// associate the new method element with the node
//
associate(node, rightElement);
// remove old node adapter and add new one
//
NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(node);
if(nodeAdapter != null) {
nodeAdapter.dispose();
}
DiagramAdapter diagramAdapter = (DiagramAdapter) getNodeAdapter(node.getActivity());
diagramAdapter.addNodeAdapterTo(node);
}
}
}
}
return result;
}
/**
* To get the eAnnotation detail based on name. (eg: type)
* @deprecated replaced with {@link #getEAnnotationDetail(EModelElement, String)}
*/
public static String getEAnnotationType(EModelElement element, String detailName) {
return getEAnnotationDetail(element, detailName);
}
public static String getEAnnotationDetail(EModelElement element, String detailName) {
EAnnotation eAnnotation = element.getEAnnotation(UMA_ELEMENT);
if(eAnnotation != null){
return (String)eAnnotation.getDetails().get(detailName);
}
return null;
}
public static String getType(ActivityNode node) {
return getEAnnotationDetail(node, UMA_TYPE);
}
/**
*
* @param e
* @return one of the type constants: {@link #UMA_ACTIVITY},
* {@link #UMA_ITERATION}, {@link #UMA_MILESTONE},
* {@link #UMA_PHASE}, {@link #UMA_TASK_DESCRIPTOR},
*/
public static String getType(BreakdownElement e) {
if(e instanceof Iteration) {
return UMA_ITERATION;
}
else if(e instanceof Phase) {
return UMA_PHASE;
}
else if(e instanceof org.eclipse.epf.uma.Activity) {
return UMA_ACTIVITY;
}
else if(e instanceof Milestone) {
return UMA_MILESTONE;
}
else if(e instanceof TaskDescriptor) {
return UMA_TASK_DESCRIPTOR;
}
else {
return null;
}
}
public static boolean isInherited(EModelElement e){
EAnnotation eAnnotation = e.getEAnnotation(ANNOTATION_INHERIRED);
if (eAnnotation != null) {
String source = eAnnotation.getSource();
if(source != null && source.length() > 0){
return true;
}
}
return false;
}
private static EClass getEClassFromType(String annotationType) {
if(UMA_ACTIVITY.equals(annotationType)) {
return UmaPackage.eINSTANCE.getActivity();
}
else if(UMA_ITERATION.equals(annotationType)) {
return UmaPackage.eINSTANCE.getIteration();
} else if(UMA_MILESTONE.equals(annotationType)) {
return UmaPackage.eINSTANCE.getMilestone();
} else if(UMA_PHASE.equals(annotationType)) {
return UmaPackage.eINSTANCE.getPhase();
} else if(UMA_TASK_DESCRIPTOR.equals(annotationType)) {
return UmaPackage.eINSTANCE.getTaskDescriptor();
}
return null;
}
public static void setDefaultName(ActivityNode node) {
Activity parentAct = node.getActivity();
MethodElement element = BridgeHelper.getMethodElement(parentAct);
MethodElement obj = BridgeHelper.getMethodElement(node);
int classID = obj.eClass().getClassifierID();
org.eclipse.epf.uma.Activity act = (org.eclipse.epf.uma.Activity) element;
ArrayList siblings = new ArrayList();
for (Iterator iter = act.getBreakdownElements().iterator(); iter
.hasNext();) {
BreakdownElement e = (BreakdownElement) iter.next();
if (e.eClass().getClassifierID() == classID) {
siblings.add(e);
}
}
String baseName = MessageFormat
.format(
DiagramResources.defaultBaseName, new Object[] { TngUtil.getTypeText(obj.eClass().getName()) });
TngUtil.setDefaultName(siblings, obj, baseName);
node.setName(obj.getName());
}
public static View getView(View diagram, Object node) {
for (Iterator iter = diagram.getChildren().iterator(); iter.hasNext();) {
View child = (View) iter.next();
if(child.getElement() == node) {
return child;
}
if(child.getElement() instanceof ActivityPartition){
for (Iterator iterator = child.getChildren().iterator(); iterator
.hasNext();) {
View element = (View) iterator.next();
if(element.getElement() == node) {
return child;
}
}
}
}
return null;
}
/**
* Gets node name for the given method element.
*
* @param e
* @return
*/
public static String getNodeName(MethodElement e) {
if(e instanceof BreakdownElement) {
return ProcessUtil.getPresentationName((BreakdownElement) e);
}
else if(e instanceof DescribableElement) {
return ((DescribableElement)e).getPresentationName();
}
else {
return e.getName();
}
}
}