| //------------------------------------------------------------------------------ |
| // 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.migration.diagram.ad.map; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.draw2d.AbsoluteBendpoint; |
| import org.eclipse.draw2d.geometry.Dimension; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.draw2d.geometry.PrecisionPoint; |
| import org.eclipse.epf.diagram.ad.edit.parts.ActivityFinalNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.DecisionNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.ForkNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.JoinNodeEditPart; |
| import org.eclipse.epf.diagram.ad.edit.parts.MergeNodeEditPart; |
| import org.eclipse.epf.diagram.core.bridge.BridgeHelper; |
| import org.eclipse.epf.diagram.core.util.DiagramCoreUtil; |
| import org.eclipse.epf.diagram.model.Link; |
| import org.eclipse.epf.diagram.model.NamedNode; |
| import org.eclipse.epf.diagram.model.Node; |
| import org.eclipse.gmf.runtime.notation.Bounds; |
| import org.eclipse.gmf.runtime.notation.Diagram; |
| import org.eclipse.gmf.runtime.notation.Edge; |
| import org.eclipse.gmf.runtime.notation.IdentityAnchor; |
| import org.eclipse.gmf.runtime.notation.NotationFactory; |
| import org.eclipse.gmf.runtime.notation.RelativeBendpoints; |
| import org.eclipse.gmf.runtime.notation.View; |
| import org.eclipse.gmf.runtime.notation.datatype.RelativeBendpoint; |
| import org.eclipse.uml2.uml.Activity; |
| import org.eclipse.uml2.uml.ActivityNode; |
| import org.eclipse.uml2.uml.ControlFlow; |
| import org.eclipse.uml2.uml.UMLPackage; |
| |
| /** |
| * @author Shashidhar Kannoori |
| * @author Shilpa Toraskar |
| * @since 1.2 |
| * |
| */ |
| public class MapNode implements IMapConstants { |
| |
| protected Node node; |
| |
| //private ResourceSet resourceSet; |
| |
| protected org.eclipse.gmf.runtime.notation.Node notationNode; |
| |
| private Activity activity; |
| |
| private Diagram diagram; |
| |
| protected String name; |
| |
| protected ActivityNode umlNode; |
| |
| private static final int IMAGE_HEIGHT = 32; |
| |
| public MapNode(Node node) { |
| this.node = node; |
| } |
| |
| public MapNode() { |
| } |
| |
| /** |
| * Update resource |
| * |
| * @param resourceSet |
| * @return |
| */ |
| public org.eclipse.gmf.runtime.notation.Node updateResource() { |
| Diagram diagram = getDiagram(); |
| |
| // Check if notation element already created. |
| if (graphUMLNodeMap.get(node) != null) { |
| org.eclipse.uml2.uml.ActivityNode tempUMLNode = (ActivityNode) graphUMLNodeMap |
| .get(node); |
| org.eclipse.gmf.runtime.notation.Node tempNotationNode = findNotationNode( |
| diagram, tempUMLNode); |
| if (tempNotationNode != null) |
| return tempNotationNode; |
| |
| } |
| |
| // Create Activity Node |
| updateNode(); |
| |
| // Create Notation nnode |
| notationNode = MapUtil.createNotationNode_AD(diagram, umlNode); |
| diagram.insertChild(notationNode); |
| |
| // set size |
| setLayoutConstraint(node, notationNode); |
| |
| // set element |
| notationNode.setElement(umlNode); |
| |
| // mark inherited |
| setInheritedAttribute(node, notationNode); |
| |
| return notationNode; |
| } |
| |
| |
| /** |
| * @param node |
| * @param notationNode |
| */ |
| private void setLayoutConstraint(org.eclipse.epf.diagram.model.Node node, |
| org.eclipse.gmf.runtime.notation.Node notationNode) { |
| Bounds bounds = NotationFactory.eINSTANCE.createBounds(); |
| |
| int type = new Integer(notationNode.getType()).intValue(); |
| if (node.getHeight() == -1) { |
| if (type == DecisionNodeEditPart.VISUAL_ID || type == MergeNodeEditPart.VISUAL_ID) { |
| bounds.setHeight(24); |
| } |
| else if (type == ForkNodeEditPart.VISUAL_ID || type == JoinNodeEditPart.VISUAL_ID) { |
| bounds.setHeight(5); |
| } |
| else if (type == ActivityFinalNodeEditPart.VISUAL_ID){ |
| bounds.setHeight(24); |
| } |
| } else { |
| bounds.setHeight(node.getHeight()); |
| } |
| |
| // Due to bug in old diagram, some of the decisionNode width is -1 |
| if ((node.getWidth() == -1) && (type == DecisionNodeEditPart.VISUAL_ID |
| || type == MergeNodeEditPart.VISUAL_ID)) { |
| bounds.setWidth(48); |
| } else { |
| bounds.setWidth(node.getWidth()); |
| } |
| |
| int w = bounds.getWidth(); |
| int h = bounds.getHeight(); |
| Dimension dim = DiagramCoreUtil.getTextSizeInWrapLabel(name, null, w, h, null); |
| int dimw = dim.width; |
| if (w < dimw && dimw != 0) { |
| bounds.setWidth(dimw); |
| } |
| |
| // bounds.setHeight(node.getHeight()); |
| // bounds.setWidth(node.getWidth()); |
| bounds.setX(node.getLocation().x); |
| bounds.setY(node.getLocation().y); |
| notationNode.setLayoutConstraint(bounds); |
| } |
| |
| /** |
| * Set inherited attribute |
| * @param node |
| * @param notationNode |
| */ |
| private void setInheritedAttribute(org.eclipse.epf.diagram.model.Node node, |
| org.eclipse.gmf.runtime.notation.Node notationNode) { |
| if (node.getLinkedElement() == null) { |
| if (node.getGraphNode().getBriefDescription() != null |
| && !(node.getGraphNode().getBriefDescription().trim() |
| .equals(""))) //$NON-NLS-1$ |
| BridgeHelper.markInherited(notationNode); |
| } |
| } |
| |
| |
| /** |
| * Find corresponding notation node for the uml node in the diagram |
| * @param diagram |
| * @param umlNode |
| * @return |
| */ |
| private org.eclipse.gmf.runtime.notation.Node findNotationNode( |
| Diagram diagram, ActivityNode umlNode) { |
| List list = diagram.getChildren(); |
| if (list != null && list.size() > 0) { |
| for (Iterator iterator = list.iterator(); iterator.hasNext();) { |
| org.eclipse.gmf.runtime.notation.Node node = (org.eclipse.gmf.runtime.notation.Node) iterator |
| .next(); |
| if (umlNode.equals(node.getElement())) { |
| return node; |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Update Uml node |
| */ |
| public void updateNode() { |
| if (node instanceof NamedNode) { |
| name = ((NamedNode) node).getName(); |
| } |
| } |
| |
| /** |
| * Create outgoing connections |
| * @param node |
| */ |
| public void outgoingConnections(Node node) { |
| List connections = node.getOutgoingConnections(); |
| |
| if (connections != null && connections.size() > 0) { |
| for (Iterator iterator = connections.iterator(); iterator.hasNext();) { |
| Link link = (Link) iterator.next(); |
| |
| // create connection |
| Edge edge = createConnection(link); |
| |
| ActivityNode sourceNode = (org.eclipse.uml2.uml.ActivityNode) graphUMLNodeMap |
| .get(node); |
| org.eclipse.gmf.runtime.notation.Node sourceNotationNode = findNotationNode( |
| getDiagram(), sourceNode); |
| |
| // add the edge as source edge |
| sourceNotationNode.getSourceEdges().add(edge); |
| sourceNotationNode.getDiagram().insertEdge(edge); |
| |
| } |
| } |
| } |
| |
| /** |
| * Create UML control flow |
| * @return |
| */ |
| private ControlFlow createControlFlow() { |
| ControlFlow controlFlow = (org.eclipse.uml2.uml.ControlFlow) getActivity() |
| .createEdge("", /*MigrationResources.GRAPH_NODE_LINK,*/ //$NON-NLS-1$ |
| UMLPackage.eINSTANCE.getControlFlow()); |
| |
| return controlFlow; |
| } |
| |
| /** |
| * Loads source and target end points for synchronization bar and decision node |
| * @param edge |
| * @param flow |
| */ |
| private void loadSourceAndTargetEndPoint(Edge edge, Link flow) { |
| Point srcPoint = flow.getSourceEndPoint(); |
| Point targetPoint = flow.getTargetEndPoint(); |
| |
| View srcView = edge.getSource(); |
| View targetView = edge.getTarget(); |
| int srcType = new Integer(srcView.getType()).intValue(); |
| int targetType = new Integer(targetView.getType()).intValue(); |
| |
| if (srcType == ForkNodeEditPart.VISUAL_ID || srcType == JoinNodeEditPart.VISUAL_ID || |
| srcType == DecisionNodeEditPart.VISUAL_ID || srcType == MergeNodeEditPart.VISUAL_ID) { |
| if (srcPoint != null |
| && srcView instanceof org.eclipse.gmf.runtime.notation.Node ) { |
| Bounds bounds = (Bounds) ((org.eclipse.gmf.runtime.notation.Node) srcView) |
| .getLayoutConstraint(); |
| IdentityAnchor anchor = createIdentityAnchor(srcPoint, bounds); |
| if (anchor != null) |
| edge.setSourceAnchor(anchor); |
| } |
| } |
| if (targetType == ForkNodeEditPart.VISUAL_ID || targetType == JoinNodeEditPart.VISUAL_ID || |
| targetType == DecisionNodeEditPart.VISUAL_ID || targetType == MergeNodeEditPart.VISUAL_ID) { |
| if (targetPoint != null |
| && targetView instanceof org.eclipse.gmf.runtime.notation.Node) { |
| Bounds bounds = (Bounds) ((org.eclipse.gmf.runtime.notation.Node) targetView) |
| .getLayoutConstraint(); |
| IdentityAnchor anchor = createIdentityAnchor(targetPoint, bounds); |
| if (anchor != null) |
| edge.setTargetAnchor(anchor); |
| } |
| } |
| } |
| |
| |
| /** |
| * Create identity anchor |
| * @param point |
| * @param bounds |
| * @return |
| */ |
| private IdentityAnchor createIdentityAnchor(Point point, Bounds bounds) { |
| Point tempPoint = new Point(bounds.getX() + point.x, bounds.getY() |
| + point.y); |
| |
| PrecisionPoint prePoint = MapUtil.getAnchorRelativeLocation(tempPoint, bounds); |
| String id = MapUtil.composeTerminalString(prePoint); |
| |
| IdentityAnchor value = NotationFactory.eINSTANCE.createIdentityAnchor(); |
| value.setId(id); |
| |
| return value; |
| } |
| |
| |
| |
| /** |
| * Load relative bend points |
| * @param edge |
| * @param flow |
| */ |
| private void loadBendPoints(Edge edge, Link flow) { |
| List list = flow.getBendpoints(); |
| List<RelativeBendpoint> relativePoints = new ArrayList<RelativeBendpoint>(); |
| |
| RelativeBendpoint rbp = new RelativeBendpoint(0, 0, 0, 0); |
| |
| relativePoints.add(rbp); |
| if (list != null && list.size() > 0) { |
| for (Iterator iterator = list.iterator(); iterator.hasNext();) { |
| AbsoluteBendpoint abp = (AbsoluteBendpoint) iterator.next(); |
| |
| org.eclipse.gmf.runtime.notation.Node srcNode = (org.eclipse.gmf.runtime.notation.Node) edge.getSource(); |
| org.eclipse.gmf.runtime.notation.Node targetNode = (org.eclipse.gmf.runtime.notation.Node) edge.getTarget(); |
| int srcType = new Integer(srcNode.getType()).intValue(); |
| int targetType = new Integer(targetNode.getType()).intValue(); |
| |
| Bounds sourceBounds = (Bounds) srcNode.getLayoutConstraint(); |
| Bounds targetBounds = (Bounds) targetNode.getLayoutConstraint(); |
| |
| int srcLine = MapUtil.getNoOfLines(srcNode); |
| int targetLine = MapUtil.getNoOfLines(targetNode); |
| int srcHeight = MapUtil.getTextHeight(srcNode); |
| int targetHeight = MapUtil.getTextHeight(targetNode); |
| |
| int srcX = sourceBounds.getX() + sourceBounds.getWidth() / 2; |
| int srcY = sourceBounds.getY() + (IMAGE_HEIGHT + (srcLine * srcHeight)) / 2; |
| int tarX = targetBounds.getX() + targetBounds.getWidth() / 2; |
| int tarY = targetBounds.getY() + (IMAGE_HEIGHT + (targetLine * targetHeight)) / 2; |
| |
| if (srcType == ForkNodeEditPart.VISUAL_ID |
| || srcType == JoinNodeEditPart.VISUAL_ID |
| || srcType == DecisionNodeEditPart.VISUAL_ID |
| || srcType == MergeNodeEditPart.VISUAL_ID) { |
| Point srcPoint = flow.getSourceEndPoint(); |
| if (srcPoint != null) { |
| srcX = sourceBounds.getX() + srcPoint.x; |
| srcY = sourceBounds.getY() + srcPoint.y; |
| } |
| } |
| if (targetType == ForkNodeEditPart.VISUAL_ID |
| || targetType == JoinNodeEditPart.VISUAL_ID |
| || targetType == DecisionNodeEditPart.VISUAL_ID |
| || targetType == MergeNodeEditPart.VISUAL_ID) { |
| Point targetPoint = flow.getTargetEndPoint(); |
| if (targetPoint != null) { |
| tarX = targetBounds.getX() + targetPoint.x; |
| tarY = targetBounds.getY() + targetPoint.y; |
| } |
| } |
| if (targetType == ActivityFinalNodeEditPart.VISUAL_ID){ |
| tarX = targetBounds.getX() + targetBounds.getWidth() / 2; |
| tarY = targetBounds.getY() + targetBounds.getHeight() / 2; |
| } |
| |
| int rel1 = abp.x - srcX; |
| int rel2 = abp.y - srcY; |
| int rel3 = abp.x - tarX; |
| int rel4 = abp.y - tarY; |
| |
| RelativeBendpoint rbp1 = new RelativeBendpoint(rel1, rel2, |
| rel3, rel4); |
| relativePoints.add(rbp1); |
| } |
| } |
| relativePoints.add(rbp); |
| |
| if (relativePoints.size() > 0) { |
| RelativeBendpoints bendpoints = NotationFactory.eINSTANCE |
| .createRelativeBendpoints(); |
| bendpoints.setPoints(relativePoints); |
| edge.setBendpoints(bendpoints); |
| } |
| } |
| |
| /** |
| * Find edge in diagram given source and target nodes |
| * @param sourceNode |
| * @param targetNode |
| * @return |
| */ |
| private Edge findEdge(org.eclipse.gmf.runtime.notation.Node sourceNode, |
| org.eclipse.gmf.runtime.notation.Node targetNode) { |
| List list = notationNode.getDiagram().getEdges(); |
| if (list != null && list.size() > 0) { |
| for (Iterator iterator = list.iterator(); iterator.hasNext();) { |
| Edge edge = (Edge) iterator.next(); |
| if ((edge.getTarget() != null) |
| && targetNode.equals(edge.getTarget()) |
| && (edge.getSource() != null) |
| && sourceNode.equals(edge.getSource())) { |
| return edge; |
| } |
| } |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Create incoming connections |
| * @param node |
| */ |
| public void incomingConnections(Node node) { |
| List connections = node.getIncomingConnections(); |
| |
| if (connections != null && connections.size() > 0) { |
| for (Iterator iterator = connections.iterator(); iterator.hasNext();) { |
| Link link = (Link) iterator.next(); |
| |
| // create edge |
| Edge edge = createConnection(link); |
| |
| ActivityNode sourceNode = (org.eclipse.uml2.uml.ActivityNode) graphUMLNodeMap |
| .get(node); |
| org.eclipse.gmf.runtime.notation.Node sourceNotationNode = findNotationNode( |
| getDiagram(), sourceNode); |
| |
| // add the edge as target edge |
| sourceNotationNode.getTargetEdges().add(edge); |
| sourceNotationNode.getDiagram().insertEdge(edge); |
| } |
| } |
| } |
| |
| /** |
| * Create notation edge for the given link |
| * @param link |
| * @return |
| */ |
| private Edge createConnection(Link link) { |
| // get source and target objects of the link |
| Node sourceObj = link.getSource(); |
| Node targetObj = link.getTarget(); |
| |
| // get uml nodes |
| ActivityNode sourceUMLNode = (org.eclipse.uml2.uml.ActivityNode) graphUMLNodeMap |
| .get(sourceObj); |
| ActivityNode targetUMLNode = (org.eclipse.uml2.uml.ActivityNode) graphUMLNodeMap |
| .get(targetObj); |
| |
| // get notation nodes |
| org.eclipse.gmf.runtime.notation.Node sourceNotationNode = findNotationNode( |
| getDiagram(), sourceUMLNode); |
| org.eclipse.gmf.runtime.notation.Node targetNotationNode = findNotationNode( |
| getDiagram(), targetUMLNode); |
| |
| Edge edge = findEdge(sourceNotationNode, targetNotationNode); |
| if (edge == null && targetNotationNode != null) { |
| ControlFlow controlFlow = createControlFlow(); |
| |
| if (targetUMLNode instanceof ActivityNode) { |
| controlFlow.setSource((ActivityNode) sourceUMLNode); |
| controlFlow.setTarget((ActivityNode) targetUMLNode); |
| } |
| |
| // create notation edge |
| edge = MapUtil.createEdge_AD(sourceNotationNode, targetNotationNode, |
| controlFlow); |
| edge.setElement(controlFlow); |
| loadSourceAndTargetEndPoint(edge, link); |
| loadBendPoints(edge, link); |
| } |
| return edge; |
| } |
| |
| // private Edge findEdge(org.eclipse.uml2.uml.ControlFlow flow, Diagram |
| // diagram) { |
| // List list = diagram.getChildren(); |
| // for (Iterator iterator = list.iterator(); iterator.hasNext();) { |
| // Object object = iterator.next(); |
| // if (object instanceof Edge) { |
| // Object element = ((Edge) object).getElement(); |
| // if (flow.equals(element)) { |
| // return (Edge) object; |
| // } |
| // } |
| // } |
| // return null; |
| // } |
| |
| private Diagram getDiagram() { |
| /* if (diagram == null) { |
| Resource resource = (Resource) resourceSet.getResources().get(0); |
| diagram = (Diagram) resource.getContents().get(1); |
| }*/ |
| return diagram; |
| } |
| |
| public Activity getActivity() { |
| /* if (activity == null) { |
| // return |
| // (Activity)((Model)getUMLObject()).allOwnedElements().get(0); |
| Resource resource = (Resource) resourceSet.getResources().get(0); |
| activity = (Activity) resource.getContents().get(0); |
| }*/ |
| return activity; |
| } |
| // public EObject getUMLObject(){ |
| // if(eObject == null){ |
| // |
| // eObject = (Activity)getResource(0).getContents().get(0); |
| // } |
| // return eObject; |
| // } |
| |
| public void setDiagram(Diagram diagram) { |
| this.diagram = diagram; |
| } |
| |
| public void setActivity(Activity activity) { |
| this.activity = activity; |
| } |
| |
| // private Resource getResource(int i){ |
| // return (Resource)resourceSet.getResources().get(i); |
| // } |
| |
| } |
