| //------------------------------------------------------------------------------ |
| // Copyright (c) 2005, 2006 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.util; |
| |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.emf.common.notify.AdapterFactory; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.edit.provider.AdapterFactoryTreeIterator; |
| import org.eclipse.emf.edit.provider.ITreeItemContentProvider; |
| import org.eclipse.epf.diagram.core.DiagramCoreResources; |
| import org.eclipse.epf.diagram.core.bridge.BridgeHelper; |
| import org.eclipse.epf.diagram.core.bridge.NodeAdapter; |
| import org.eclipse.epf.diagram.core.services.DiagramHelper; |
| import org.eclipse.epf.diagram.model.ActivityDetailDiagram; |
| import org.eclipse.epf.diagram.model.ActivityDiagram; |
| import org.eclipse.epf.diagram.model.Link; |
| import org.eclipse.epf.diagram.model.RoleNode; |
| import org.eclipse.epf.diagram.model.TaskNode; |
| import org.eclipse.epf.diagram.model.TypedNode; |
| import org.eclipse.epf.diagram.model.WorkBreakdownElementNode; |
| import org.eclipse.epf.diagram.model.util.GraphicalDataHelper; |
| import org.eclipse.epf.library.edit.TngAdapterFactory; |
| import org.eclipse.epf.library.edit.process.IBSItemProvider; |
| import org.eclipse.epf.library.edit.util.IDiagramManager; |
| import org.eclipse.epf.library.edit.util.MethodElementPropertyHelper; |
| 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.MethodElement; |
| import org.eclipse.epf.uma.WorkBreakdownElement; |
| import org.eclipse.epf.uma.WorkOrder; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart; |
| import org.eclipse.gmf.runtime.notation.Diagram; |
| import org.eclipse.gmf.runtime.notation.Edge; |
| import org.eclipse.gmf.runtime.notation.Node; |
| import org.eclipse.gmf.runtime.notation.View; |
| import org.eclipse.uml2.uml.ActivityEdge; |
| import org.eclipse.uml2.uml.ActivityNode; |
| import org.eclipse.uml2.uml.ControlNode; |
| import org.eclipse.uml2.uml.FinalNode; |
| import org.eclipse.uml2.uml.ForkNode; |
| import org.eclipse.uml2.uml.InitialNode; |
| import org.eclipse.uml2.uml.JoinNode; |
| |
| /** |
| * Validating routines for diagram editing |
| * |
| * @author Phong Nguyen Le |
| * @author Shashidhar Kannoori |
| * @since 1.0 |
| */ |
| public class DiagramCoreValidation { |
| |
| private static final String errMsg_CanNotConnect = DiagramCoreResources.DiagramValidation_err_cannot_connect_text; //$NON-NLS-1$ |
| |
| private static final String errMsg_SamePredAndSucc = DiagramCoreResources.DiagramValidation_err_samepredandsuc_text; //$NON-NLS-1$ |
| |
| private static final String errMsg_CanNotDelete = DiagramCoreResources.DiagramValidation_err_cannot_delete_text; //$NON-NLS-1$ |
| |
| public static boolean isConnectionToReadOnlyTargetAllowed() { |
| // return DiagramPreferences.getADAllowConnectionToReadOnlyElements(); |
| return true; |
| } |
| |
| public static String isTargetReadonly(EditPart part){ |
| View view = (View)part.getModel(); |
| if(BridgeHelper.isReadOnly(view)) return errMsg_CanNotConnect; |
| return null; |
| } |
| |
| public static String canConnect(EditPart targetEditPart, EObject sourceElement, EObject targetElement){ |
| |
| if(targetEditPart == null) return errMsg_CanNotConnect; |
| |
| EditPart part = targetEditPart.getParent(); |
| Diagram diagram = null; |
| while(part != null && !(part instanceof DiagramEditPart)){ |
| part = part.getParent(); |
| } |
| if(part instanceof DiagramEditPart){ |
| diagram = (Diagram)((DiagramEditPart)part).getModel(); |
| } |
| |
| if(diagram == null) return errMsg_CanNotConnect; |
| return checkConnect(diagram, sourceElement, targetElement); |
| } |
| |
| public static String checkConnect(Diagram diagram, EObject sourceElement, EObject targetElement){ |
| switch(DiagramHelper.getDiagramType(diagram)){ |
| case IDiagramManager.ACTIVITY_DIAGRAM: |
| if(alwaysAllowed(sourceElement, targetElement)) { |
| return null; |
| } |
| |
| // If target Diagram is read-only - do not connect |
| if(BridgeHelper.isReadOnly(diagram)) return errMsg_CanNotConnect; |
| |
| NodeAdapter sourceAdapter = BridgeHelper.getNodeAdapter(sourceElement); |
| NodeAdapter targetAdapter = BridgeHelper.getNodeAdapter(targetElement); |
| |
| // if adapters of source and target is null - no connect. |
| if(sourceAdapter == null || targetAdapter == null) return errMsg_CanNotConnect; |
| |
| Diagram sourceDiagram = sourceAdapter.getView().getDiagram(); |
| |
| // If source and target diagrams not equal - do not connect. |
| if (!diagram.equals(sourceDiagram)) |
| return errMsg_CanNotConnect; |
| |
| AdapterFactory adapterFactory = TngAdapterFactory.INSTANCE |
| .getWBS_ComposedAdapterFactory(); |
| Object adapter = adapterFactory.adapt(BridgeHelper.getMethodElement(sourceDiagram) |
| , ITreeItemContentProvider.class); |
| Object proc = null; |
| if (adapter instanceof IBSItemProvider) { |
| proc = ((IBSItemProvider) adapter).getTopItem(); |
| } |
| // get all breakdown elements in this process |
| // |
| List<Object> allElements = new ArrayList<Object>(); |
| for (Iterator iter = new AdapterFactoryTreeIterator(adapterFactory, |
| proc); iter.hasNext();) { |
| Object obj = iter.next(); |
| allElements.add(TngUtil.unwrap(obj)); |
| } |
| if(proc != null){ |
| EObject source = sourceAdapter.getElement(); |
| |
| EObject target = null; |
| if (targetAdapter != null) { |
| target = targetAdapter.getElement(); |
| } |
| if (source instanceof |
| WorkBreakdownElement) { |
| if (target instanceof WorkBreakdownElement) { |
| if (ProcessUtil.checkCircular( |
| (WorkBreakdownElement) target, |
| (WorkBreakdownElement) source, allElements)) |
| return errMsg_SamePredAndSucc; |
| |
| if (!isConnectionToReadOnlyTargetAllowed() && targetAdapter.isTargetReadOnly()) |
| return errMsg_CanNotConnect; |
| } else { |
| // target node might be control node |
| Collection<ActivityNode> actNodes = new ArrayList<ActivityNode>(); |
| BridgeHelper.getSuccessorNodes(actNodes, |
| (ActivityNode) targetElement); |
| for (ActivityNode node : actNodes) { |
| if (BridgeHelper.getNodeAdapter(node).isTargetReadOnly() && !isConnectionToReadOnlyTargetAllowed()) |
| return errMsg_CanNotConnect; |
| if (ProcessUtil.checkCircular( |
| (WorkBreakdownElement) BridgeHelper |
| .getMethodElement(node), |
| (WorkBreakdownElement) source, allElements)) { |
| return errMsg_SamePredAndSucc; |
| } |
| } |
| } |
| } else { |
| if (target instanceof WorkBreakdownElement) { |
| Collection<ActivityNode> srcNodes = new ArrayList<ActivityNode>(); |
| BridgeHelper.getPredecessorNodes(srcNodes, |
| (ActivityNode) sourceElement); |
| if (!srcNodes.isEmpty()) { |
| if (targetAdapter.isTargetReadOnly() && !isConnectionToReadOnlyTargetAllowed()) |
| return errMsg_CanNotConnect; |
| for (ActivityNode predNode : srcNodes) { |
| MethodElement pred = BridgeHelper |
| .getMethodElement(predNode); |
| if (ProcessUtil.checkCircular( |
| (WorkBreakdownElement) target, |
| (WorkBreakdownElement) pred, |
| allElements)) { |
| return errMsg_SamePredAndSucc; |
| } |
| } |
| } |
| } else { |
| if (checkSyncBarCircularLooop((ActivityNode)sourceElement, |
| (ActivityNode) targetElement) != null) { |
| return errMsg_CanNotConnect; |
| } |
| |
| // should not allow incoming connection to start node |
| // and FreeText. |
| if (targetElement instanceof InitialNode) { |
| return errMsg_CanNotConnect; |
| } |
| |
| Collection<ActivityNode> srcNodes = new ArrayList<ActivityNode>(); |
| BridgeHelper.getPredecessorNodes(srcNodes, (ActivityNode) sourceElement); |
| if (!srcNodes.isEmpty()) { |
| Collection<ActivityNode> targetNodes = new ArrayList<ActivityNode>(); |
| BridgeHelper.getSuccessorNodes(targetNodes, |
| (ActivityNode) target); |
| for (ActivityNode node : targetNodes) { |
| NodeAdapter nodeAdapter = BridgeHelper |
| .getNodeAdapter(node); |
| if (nodeAdapter.isTargetReadOnly() && !isConnectionToReadOnlyTargetAllowed()) |
| return errMsg_CanNotConnect; |
| WorkBreakdownElement succ = (WorkBreakdownElement) nodeAdapter |
| .getElement(); |
| for (ActivityNode prednode : srcNodes) { |
| NodeAdapter predAdapter = BridgeHelper |
| .getNodeAdapter(prednode); |
| WorkBreakdownElement pred = (WorkBreakdownElement) predAdapter |
| .getElement(); |
| if (ProcessUtil.checkCircular(succ, pred, |
| allElements)) { |
| return errMsg_SamePredAndSucc; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| } |
| } |
| |
| return null; |
| } |
| |
| /* |
| * To avoid circular looping between synchronization bars. If SycnBar1 -> |
| * SyncBar2 (connected) then SyncBar2 -> SyncBar1 cannot connect. if |
| * syncbar1 -> syncbar2->syncbar3 then syncbar3 -> syncbar1 disallowed. |
| * |
| */ |
| public static String checkSyncBarCircularLooop(ActivityNode sNode, |
| ActivityNode tNode) { |
| List list = tNode.getOutgoings(); |
| if (!list.isEmpty() && list.size() > 0) { |
| for (Iterator iterator = list.iterator(); iterator.hasNext();) { |
| ActivityEdge link = (ActivityEdge) iterator.next(); |
| ActivityNode typednode = link.getTarget(); |
| if (sNode.equals(typednode)) |
| return errMsg_CanNotConnect; |
| if (typednode instanceof ControlNode) { |
| return checkSyncBarCircularLooop(sNode, |
| (ControlNode)typednode); |
| } |
| } |
| } |
| return null; |
| } |
| |
| /* |
| * Method to Check if SyncBar inComming connections have |
| * any source is a readonly. |
| * @return |
| */ |
| public static String checkSyncBarIncomingLinks(ActivityNode typedNode){ |
| for (Iterator iter = typedNode.getIncomings().iterator(); iter.hasNext();) { |
| ActivityEdge link = (ActivityEdge) iter.next(); |
| ActivityNode source = link.getSource(); |
| NodeAdapter adapter = BridgeHelper.getNodeAdapter(source); |
| if (adapter != null) { |
| if(adapter.getElement() instanceof WorkBreakdownElement){ |
| if(adapter.isTargetReadOnly()) |
| return errMsg_CanNotDelete; |
| }else if(source instanceof ControlNode){ |
| if(source instanceof ForkNode || source instanceof JoinNode) |
| if(checkSyncBarIncomingLinks(source)!= null) |
| return errMsg_CanNotDelete; |
| } |
| } |
| } |
| return null; |
| } |
| /* |
| *Method to check if synchronization bar outgoing connection |
| *has any target is readonly. |
| */ |
| public static String checkSyncBarOutgoingLinks(ActivityNode typedNode){ |
| for (Iterator iter = typedNode.getOutgoings().iterator(); iter.hasNext();) { |
| ActivityEdge link = (ActivityEdge) iter.next(); |
| ActivityNode target = link.getTarget(); |
| NodeAdapter adapter = BridgeHelper.getNodeAdapter(target); |
| if (adapter != null) { |
| if(adapter.getElement() instanceof WorkBreakdownElement){ |
| if(adapter.isTargetReadOnly()) |
| return errMsg_CanNotDelete; |
| }else if(target instanceof ControlNode){ |
| if(target instanceof ForkNode || target instanceof JoinNode) |
| if(checkSyncBarOutgoingLinks(target)!= null) |
| return errMsg_CanNotDelete; |
| } |
| } |
| } |
| return null; |
| } |
| |
| |
| public static String checkDelete(Node node) { |
| if (BridgeHelper.isReadOnly(node)) |
| return errMsg_CanNotDelete; |
| Diagram diagram = node.getDiagram(); |
| if (diagram instanceof ActivityDiagram) { |
| if (node.getElement() instanceof ControlNode) { |
| |
| Collection<ActivityNode> targetNodes = new ArrayList<ActivityNode>(); |
| BridgeHelper.getSuccessorNodes(targetNodes, (ActivityNode)node.getElement()); |
| |
| for (ActivityNode targetNode : targetNodes) { |
| NodeAdapter adapter = BridgeHelper.getNodeAdapter(targetNode); |
| if(adapter != null && adapter.isTargetReadOnly()){ |
| return errMsg_CanNotDelete; |
| } |
| } |
| } |
| } else if (diagram instanceof ActivityDetailDiagram) { |
| if (node.getElement() instanceof RoleNode) { |
| return errMsg_CanNotDelete; |
| } |
| } |
| return null; |
| } |
| |
| public static String checkReconnect(Node source, Node target, Edge link) { |
| if (source.getDiagram() instanceof ActivityDiagram) { |
| if (link.getTarget() != null) { |
| if (BridgeHelper.isReadOnly(link.getTarget())) { |
| return errMsg_CanNotConnect; |
| } else { |
| if (link.getTarget() instanceof TypedNode) { |
| Collection targetNodes = GraphicalDataHelper |
| .getTargetNodes((TypedNode) link.getTarget(), |
| WorkBreakdownElementNode.class); |
| for (Iterator iter = targetNodes.iterator(); iter |
| .hasNext();) { |
| Node node = (Node) iter.next(); |
| if (BridgeHelper.isReadOnly(node)) { |
| return errMsg_CanNotConnect; |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return checkConnect(source, target, link); |
| } |
| |
| /* |
| * Method will not allow multiple link between two nodes. Needs to call |
| * CreakLinkCommand and ReconnectLinkCommand. Any action on a Link should |
| * call this checkConnect(Node source, Node target, Link link) before allow |
| * to connect. |
| */ |
| public static String checkConnect(Node source, Node target, Edge link) { |
| |
| if (source == target && !(BridgeHelper.getMethodElement(source) instanceof Activity)) { |
| return errMsg_CanNotConnect; |
| } |
| |
| List links = source.getTargetEdges(); |
| if (links != null) { |
| // This is need for reconnect to same target node. |
| if (links.contains(link)) { |
| if (link.getTarget().equals(target)) { |
| return null; |
| } |
| } |
| // This is need for new connect and reconnect to different target node. |
| for (Iterator iter = links.iterator(); iter.hasNext();) { |
| Link linkx = (Link) iter.next(); |
| Object linkxtarget = linkx.getTarget(); |
| if (linkxtarget != null && linkxtarget.equals(target)) { |
| return errMsg_CanNotConnect; |
| } |
| } |
| } |
| return checkConnect(source.getDiagram(), source.getElement(), target.getElement()); |
| } |
| |
| private static boolean alwaysAllowed(Object sourceElement, Object targetElement) { |
| return sourceElement instanceof InitialNode |
| || targetElement instanceof FinalNode |
| || (sourceElement instanceof ControlNode && !BridgeHelper.isSynchBar((ControlNode)sourceElement)) |
| || (targetElement instanceof ControlNode && !BridgeHelper.isSynchBar((ControlNode)targetElement)); |
| } |
| |
| /* |
| * Checks if the given edge is a regular edge, means, it is not a special |
| * edge that is created in extended diagram with a inherited, read-only |
| * target. |
| */ |
| private static boolean isRegularEdge(Edge edge) { |
| MethodElement workOrder = BridgeHelper.getMethodElement(edge); |
| return workOrder == null || MethodElementPropertyHelper.getProperty(workOrder, MethodElementPropertyHelper.WORK_ORDER__SUCCESSOR) == null; |
| } |
| |
| public static String checkDelete(Edge edge) { |
| View source = edge.getSource(); |
| View target = edge.getTarget(); |
| |
| if(target != null){ |
| Diagram diagram = target.getDiagram(); |
| switch(DiagramHelper.getDiagramType(diagram)){ |
| case IDiagramManager.ACTIVITY_DIAGRAM: |
| EObject sourceElement = source.getElement(); |
| EObject targetElement = target.getElement(); |
| if(alwaysAllowed(sourceElement, targetElement)) { |
| return null; |
| } |
| if(BridgeHelper.isInherited(edge)) { |
| return errMsg_CanNotDelete; |
| } else if(BridgeHelper.isReadOnly(source) && BridgeHelper.isReadOnly(target)) { |
| // check if this edge is a custom one |
| // |
| MethodElement me = BridgeHelper.getMethodElement(edge); |
| if(me instanceof WorkOrder && ProcessUtil.isCustomWorkOrder((WorkOrder) me)) { |
| return null; |
| } else { |
| // edge is automatically created for 2 inherited |
| // predecessor/successor and cannot be deleted |
| // |
| return errMsg_CanNotDelete; |
| } |
| } |
| |
| // Since making connection to a inherited, read-only target is |
| // allowed now, the check logic below is no longer needed. We |
| // only need to prevented inherited connections and nodes from |
| // deletion. |
| |
| // // check if this edge is representing any work order |
| // // |
| // if (sourceElement instanceof ActivityNode |
| // && BridgeHelper.getMethodElement(sourceElement) == null) { |
| // Collection<ActivityNode> actNodes = new ArrayList<ActivityNode>(); |
| // BridgeHelper.getSourceNodes(actNodes, |
| // (ActivityNode) sourceElement, |
| // WorkBreakdownElement.class); |
| // if (actNodes.isEmpty()) { |
| // return null; |
| // } |
| // } |
| // |
| // // the edge does represent a work order |
| // |
| // if(BridgeHelper.isReadOnly(target)) { |
| // if(BridgeHelper.getMethodElement(sourceElement) instanceof WorkBreakdownElement) |
| // return errMsg_CanNotDelete; |
| // } |
| // |
| // if(targetElement instanceof ActivityNode) { |
| // NodeAdapter adapter = BridgeHelper.getNodeAdapter(targetElement); |
| // if(adapter != null && adapter.getElement() instanceof WorkBreakdownElement) { |
| // return null; |
| // } |
| //// // target does not represent a work breakdown element |
| //// // disallow deletion of the edge if one of the target nodes of the target is read-only or inherited |
| //// // |
| //// Collection<ActivityNode> actNodes = new ArrayList<ActivityNode>(); |
| //// BridgeHelper.getSuccessorNodes(actNodes, (ActivityNode) targetElement); |
| //// for (ActivityNode activityNode : actNodes) { |
| //// View view = BridgeHelper.getView(diagram, activityNode); |
| //// if(view != null && BridgeHelper.isReadOnly(view)) { |
| //// return errMsg_CanNotDelete; |
| //// } |
| //// } |
| // |
| // if(BridgeHelper.isSynchBar((ActivityNode)targetElement)) { |
| // return checkSyncBarOutgoingLinks((ActivityNode)targetElement); |
| // } |
| // |
| // } |
| |
| return null; |
| case IDiagramManager.ACTIVITY_DETAIL_DIAGRAM: |
| return errMsg_CanNotDelete; |
| |
| case IDiagramManager.WORK_PRODUCT_DEPENDENCY_DIAGRAM: |
| if(BridgeHelper.isReadOnly(target)) |
| return errMsg_CanNotDelete; |
| return null; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Check to see link is readonly. |
| */ |
| public static boolean isReadOnly(Edge edge) { |
| |
| View target = edge.getTarget(); |
| View source = edge.getSource(); |
| if (target != null |
| && target.getDiagram().getElement() instanceof ActivityDetailDiagram) { |
| if(source != null){ |
| Object sourceElement = source.getElement(); |
| if(sourceElement != null && sourceElement instanceof TaskNode |
| && ((TaskNode)sourceElement).isReadOnly()){ |
| return true; |
| } |
| } |
| if(target != null){ |
| Object targetElement = target.getElement(); |
| if(targetElement != null && targetElement instanceof TaskNode |
| && ((TaskNode)targetElement).isReadOnly()){ |
| return true; |
| } |
| } |
| } else { |
| return checkDelete(edge) != null; |
| } |
| return false; |
| } |
| |
| /** |
| * Check if any duplicate links between two ends already exists. |
| * |
| * */ |
| public static boolean isDuplicateRelationship(EObject source, EObject target) { |
| EObject container = source.eContainer(); |
| if (container instanceof org.eclipse.uml2.uml.Activity) { |
| org.eclipse.uml2.uml.Activity activity = (org.eclipse.uml2.uml.Activity) container; |
| List<ActivityEdge> list = activity.getEdges(); |
| for (Iterator<ActivityEdge> iter = list.iterator(); iter.hasNext();) { |
| ActivityEdge element = (ActivityEdge) iter.next(); |
| if ((element.getSource() == source) |
| && element.getTarget() == target) { |
| return true; |
| } |
| } |
| } |
| return false; |
| } |
| |
| public static boolean hasVisibleTarget(ActivityNode source) { |
| List<ActivityEdge> list = source.getOutgoings(); |
| if (list != null && list.size() >= 1) { |
| // ignore outgoing connections from invisible nodes |
| // |
| for (ActivityEdge edge : list) { |
| ActivityNode node = edge.getTarget(); |
| NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(node); |
| if(nodeAdapter != null) { |
| View view = nodeAdapter.getView(); |
| if(view != null && view.isVisible()) { |
| return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| public static boolean hasVisibleSource(ActivityNode target) { |
| List<ActivityEdge> list = target.getIncomings(); |
| if (list != null && list.size() >= 1) { |
| // ignore incoming connection from invisible nodes |
| // |
| for (ActivityEdge conn : list) { |
| ActivityNode node = conn.getSource(); |
| NodeAdapter nodeAdapter = BridgeHelper.getNodeAdapter(node); |
| if(nodeAdapter != null) { |
| View view = nodeAdapter.getView(); |
| if(view != null && view.isVisible()) { |
| return true; |
| } |
| } |
| } |
| } |
| return false; |
| } |
| } |
