| //------------------------------------------------------------------------------ |
| // 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.authoring.gef.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.edit.provider.AdapterFactoryTreeIterator; |
| import org.eclipse.emf.edit.provider.ITreeItemContentProvider; |
| import org.eclipse.epf.authoring.ui.AuthoringUIResources; |
| import org.eclipse.epf.diagram.model.ActivityDetailDiagram; |
| import org.eclipse.epf.diagram.model.ActivityDiagram; |
| import org.eclipse.epf.diagram.model.Diagram; |
| import org.eclipse.epf.diagram.model.Link; |
| import org.eclipse.epf.diagram.model.Node; |
| 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.WorkProductDependencyDiagram; |
| 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.ProcessUtil; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| import org.eclipse.epf.uma.Activity; |
| import org.eclipse.epf.uma.RoleDescriptor; |
| import org.eclipse.epf.uma.TaskDescriptor; |
| import org.eclipse.epf.uma.WorkBreakdownElement; |
| import org.eclipse.epf.uma.WorkProductDescriptor; |
| |
| /** |
| * Validating routines for diagram editing |
| * |
| * @author Phong Nguyen Le |
| * @author Shashidhar Kannoori |
| * @since 1.0 |
| */ |
| public final class Validation { |
| |
| private static final String errMsg_CanNotConnect = AuthoringUIResources.DiagramValidation_err_cannot_connect_text; |
| |
| private static final String errMsg_SamePredAndSucc = AuthoringUIResources.DiagramValidation_err_samepredandsuc_text; |
| |
| private static final String errMsg_CanNotDelete = AuthoringUIResources.DiagramValidation_err_cannot_delete_text; |
| |
| /** |
| * Checks if user can connect the given nodes. |
| * |
| * @param source |
| * @param target |
| * @return null if connection is allowed, error message otherwise. |
| */ |
| public static String checkConnect(Node source, Node target) { |
| if (source.getDiagram() != target.getDiagram()) |
| return AuthoringUIResources.DiagramValidation_err_cannot_connect_text; |
| |
| if (source.getDiagram() instanceof ActivityDiagram) { |
| AdapterFactory adapterFactory = TngAdapterFactory.INSTANCE |
| .getWBS_ComposedAdapterFactory(); |
| Object adapter = adapterFactory.adapt(source.getDiagram() |
| .getObject(), 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) { |
| // If target is ReadOnly (means extends) and allow the link if |
| // its parent activity is a Contributor |
| if (target.getDiagram().isReadOnly()) |
| return errMsg_CanNotConnect; |
| if (source.getObject() instanceof WorkBreakdownElement) { |
| if (target.getObject() instanceof WorkBreakdownElement) { |
| if (ProcessUtil.checkCircular( |
| (WorkBreakdownElement) target.getObject(), |
| (WorkBreakdownElement) source.getObject(), |
| allElements)) { |
| return errMsg_SamePredAndSucc; |
| } |
| if (target.isReadOnly()) |
| return errMsg_CanNotConnect; |
| } else if (target instanceof TypedNode) { |
| // should not allow incoming connection to start node |
| // and FreeText. |
| if (((TypedNode) target).getType() == TypedNode.START |
| || ((TypedNode) target).getType() == TypedNode.FREE_TEXT) { |
| return errMsg_CanNotConnect; |
| } |
| |
| Collection targetNodes = GraphicalDataHelper |
| .getTargetNodes((TypedNode) target, |
| WorkBreakdownElementNode.class); |
| WorkBreakdownElement pred = (WorkBreakdownElement) source |
| .getObject(); |
| for (Iterator iter = targetNodes.iterator(); iter |
| .hasNext();) { |
| Node node = ((Node) iter.next()); |
| if (node.isReadOnly()) |
| return errMsg_CanNotConnect; |
| if (ProcessUtil.checkCircular( |
| (WorkBreakdownElement) node.getObject(), |
| pred, allElements)) { |
| return errMsg_SamePredAndSucc; |
| } |
| } |
| } |
| } else if (source instanceof TypedNode) { |
| if (target == source) { |
| return errMsg_CanNotConnect; |
| } |
| // should not allow outgoing connection from End Node and |
| // Free Text |
| if (((TypedNode) source).getType() == TypedNode.END |
| || ((TypedNode) source).getType() == TypedNode.FREE_TEXT) { |
| return errMsg_CanNotConnect; |
| } |
| |
| if (target instanceof TypedNode) { |
| |
| /* |
| * If source and target are TypedNodes, avoid circular |
| * loop connection. |
| */ |
| if (checkSyncBarCircularLooop((TypedNode) source, |
| (TypedNode) target) != null) { |
| return errMsg_CanNotConnect; |
| } |
| |
| // should not allow incoming connection to start node |
| // and FreeText. |
| if (((TypedNode) target).getType() == TypedNode.START |
| || ((TypedNode) target).getType() == TypedNode.FREE_TEXT) { |
| return errMsg_CanNotConnect; |
| } |
| |
| Collection srcNodes = GraphicalDataHelper |
| .getSourceNodes((TypedNode) source, |
| WorkBreakdownElementNode.class); |
| if (!srcNodes.isEmpty()) { |
| Collection targetNodes = GraphicalDataHelper |
| .getTargetNodes((TypedNode) target, |
| WorkBreakdownElementNode.class); |
| for (Iterator iter = targetNodes.iterator(); iter |
| .hasNext();) { |
| Node node = ((Node) iter.next()); |
| if (node.isReadOnly()) |
| return errMsg_CanNotConnect; |
| WorkBreakdownElement succ = (WorkBreakdownElement) node |
| .getObject(); |
| for (Iterator iterator = srcNodes.iterator(); iterator |
| .hasNext();) { |
| WorkBreakdownElement pred = (WorkBreakdownElement) ((Node) iterator |
| .next()).getObject(); |
| if (ProcessUtil.checkCircular(succ, pred, |
| allElements)) { |
| return errMsg_SamePredAndSucc; |
| } |
| } |
| } |
| } |
| } else if (target instanceof WorkBreakdownElementNode) { |
| |
| if (target.isReadOnly()) |
| return errMsg_CanNotConnect; |
| |
| Collection srcNodes = GraphicalDataHelper |
| .getSourceNodes((TypedNode) source, |
| WorkBreakdownElementNode.class); |
| WorkBreakdownElement succ = (WorkBreakdownElement) ((Node) target) |
| .getObject(); |
| for (Iterator iterator = srcNodes.iterator(); iterator |
| .hasNext();) { |
| WorkBreakdownElement pred = (WorkBreakdownElement) ((Node) iterator |
| .next()).getObject(); |
| if (ProcessUtil.checkCircular(succ, pred, |
| allElements)) { |
| return errMsg_SamePredAndSucc; |
| } |
| } |
| |
| } |
| } |
| } |
| } else if (source.getDiagram() instanceof ActivityDetailDiagram) { |
| if (source.isReadOnly() || target.isReadOnly()) { |
| return errMsg_CanNotConnect; |
| } |
| |
| if ((source.getObject() instanceof RoleDescriptor || target |
| .getObject() instanceof RoleDescriptor) |
| || (source.getObject() instanceof TaskDescriptor && target |
| .getObject() instanceof TaskDescriptor) |
| || (source.getObject() instanceof WorkProductDescriptor && target |
| .getObject() instanceof WorkProductDescriptor)) { |
| return errMsg_CanNotConnect; |
| } else { |
| // check for duplicate connection |
| // |
| for (Iterator iter = source.getOutgoingConnections().iterator(); iter |
| .hasNext();) { |
| Link link = (Link) iter.next(); |
| if (link.getTarget() == target) { |
| return errMsg_CanNotConnect; |
| } |
| } |
| |
| } |
| } else if (source.getDiagram() instanceof WorkProductDependencyDiagram) { |
| if (source.isReadOnly() || target.isReadOnly()) { |
| return errMsg_CanNotConnect; |
| } |
| } |
| |
| return null; |
| } |
| |
| public static String checkDelete(Link link) { |
| |
| // if (link.getTarget() != null |
| // && link.getTarget().getDiagram() instanceof ActivityDiagram) { |
| // if (link.getTarget().isReadOnly()){ |
| // if(link.getSource() instanceof TypedNode){ |
| // if(((TypedNode)link.getSource()).getType() == TypedNode.DECISION){ |
| // return null; |
| // } |
| // } |
| // return errMsg_CanNotDelete; |
| // } |
| // if (link.getTarget() instanceof TypedNode) { |
| // |
| // TypedNode typednode = (TypedNode)link.getTarget(); |
| // if(typednode.getType() == TypedNode.DECISION){ |
| // return null; |
| // } |
| // if(link.getSource() instanceof TypedNode){ |
| // typednode = (TypedNode)link.getSource(); |
| // if(typednode.getType() == TypedNode.DECISION){ |
| // return null; |
| // } |
| // } |
| // |
| // if (link.getSource().isReadOnly()) |
| // return errMsg_CanNotDelete; |
| // |
| // if (link.getSource().getObject() instanceof WorkBreakdownElement |
| // || (link.getSource() instanceof TypedNode && !GraphicalDataHelper |
| // .getSourceNodes((TypedNode) link.getSource(), |
| // WorkBreakdownElementNode.class) |
| // .isEmpty())) { |
| // |
| // Collection targetNodes = |
| // GraphicalDataHelper.getTargetNodes((TypedNode) link.getTarget(), |
| // WorkBreakdownElementNode.class); |
| // for (Iterator iter = targetNodes.iterator(); iter.hasNext();) { |
| // Node node = (Node) iter.next(); |
| // if (node.isReadOnly()) { |
| // return errMsg_CanNotDelete; |
| // } |
| // } |
| // } |
| // |
| // } |
| // if (link.getSource() instanceof TypedNode) { |
| // TypedNode typednode = (TypedNode)link.getSource(); |
| // if(typednode.getType() == TypedNode.DECISION){ |
| // return null; |
| // } |
| // if (link.getTarget().isReadOnly()) |
| // return errMsg_CanNotDelete; |
| // } |
| // } else if ((link.getTarget() != null && |
| // link.getTarget().isReadOnly()) |
| // || (link.getSource() != null && link.getSource().isReadOnly())) { |
| // return errMsg_CanNotDelete; |
| // } |
| // return null; |
| |
| Node source = link.getSource(); |
| Node target = link.getTarget(); |
| |
| // Special handle for Activity Detail Diagram links cannot be deleted. |
| if (target != null |
| && target.getDiagram() instanceof ActivityDetailDiagram) { |
| return errMsg_CanNotDelete; |
| } |
| |
| if (target != null && target.getDiagram() instanceof ActivityDiagram) { |
| |
| // Target = breakdownelement |
| if (target instanceof WorkBreakdownElementNode) { |
| // Source = Breakdown element |
| if (source instanceof WorkBreakdownElementNode) { |
| if (link.getTarget().isReadOnly()) |
| return errMsg_CanNotDelete; |
| else |
| return null; |
| } |
| // Source = TypedNode |
| if (source instanceof TypedNode) { |
| // Source = Decision Node |
| TypedNode sourceNode = (TypedNode) source; |
| if (!target.isReadOnly()) { |
| return null; |
| } else if (sourceNode.getType() == TypedNode.DECISION) { |
| return null; |
| } else if (sourceNode.getType() == TypedNode.SYNCH_BAR) { |
| return checkSyncBarIncomingLinks(sourceNode); |
| } else if (sourceNode.isReadOnly()) { |
| return errMsg_CanNotDelete; |
| } |
| } |
| }// Target is TypedNode |
| else if (target instanceof TypedNode) { |
| |
| TypedNode typedNode = (TypedNode) target; |
| // if Target is TypedNode and its a DecisionPoint - should be |
| // black. |
| if (typedNode.getType() == TypedNode.DECISION) { |
| return null; |
| } |
| // If Target is TypedNode and and Source is WorkBreakdownElement |
| // and readonly |
| // Link should be green. |
| if (source instanceof WorkBreakdownElementNode) { |
| // Check Target - is having any indirect(outgoing |
| // connnection) contains decision points. |
| if (checkSyncBarOutgoingLinks((TypedNode) target) == null) |
| return null; |
| if (source.isReadOnly()) |
| return errMsg_CanNotDelete; |
| } |
| if (source instanceof TypedNode) { |
| TypedNode sourceTypedNode = (TypedNode) source; |
| // Source is Typed Node and its a decision point return |
| // null. |
| if (sourceTypedNode.getType() == TypedNode.DECISION) { |
| return null; |
| } |
| // if source is SyncBar and check all its incoming |
| // connections. |
| if (sourceTypedNode.getType() == TypedNode.SYNCH_BAR) { |
| return checkSyncBarIncomingLinks(sourceTypedNode); |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| public static String checkDelete(Node node) { |
| if (node.isReadOnly()) |
| return errMsg_CanNotDelete; |
| Diagram diagram = node.getDiagram(); |
| if (diagram instanceof ActivityDiagram) { |
| if (node instanceof TypedNode) { |
| Collection targetNodes = GraphicalDataHelper.getTargetNodes( |
| (TypedNode) node, WorkBreakdownElementNode.class); |
| for (Iterator iter = targetNodes.iterator(); iter.hasNext();) { |
| Node target = (Node) iter.next(); |
| if (target.isReadOnly()) { |
| return errMsg_CanNotDelete; |
| } |
| } |
| } |
| } else if (diagram instanceof ActivityDetailDiagram) { |
| if (node instanceof RoleNode) { |
| return errMsg_CanNotDelete; |
| } |
| } |
| return null; |
| } |
| |
| public static String checkReconnect(Node source, Node target, Link link) { |
| if (source.getDiagram() instanceof ActivityDiagram) { |
| if (link.getTarget() != null) { |
| if (link.getTarget().isReadOnly()) { |
| 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 (node.isReadOnly()) { |
| 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, Link link) { |
| |
| if (source == target && !(source.getObject() instanceof Activity)) { |
| return errMsg_CanNotConnect; |
| } |
| |
| List links = source.getOutgoingConnections(); |
| 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, target); |
| } |
| |
| /* |
| * 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(TypedNode sNode, |
| TypedNode tNode) { |
| List list = tNode.getOutgoingConnections(); |
| if (!list.isEmpty() && list.size() > 0) { |
| for (Iterator iterator = list.iterator(); iterator.hasNext();) { |
| Link link = (Link) iterator.next(); |
| Node typednode = link.getTarget(); |
| if (sNode.equals(typednode)) |
| return errMsg_CanNotConnect; |
| if (typednode instanceof TypedNode) { |
| return checkSyncBarCircularLooop(sNode, |
| (TypedNode) typednode); |
| } |
| } |
| } |
| return null; |
| } |
| |
| /* |
| * Method to Check if SyncBar inComming connections have any source is a |
| * readonly. @return |
| */ |
| public static String checkSyncBarIncomingLinks(TypedNode typedNode) { |
| for (Iterator iter = typedNode.getIncomingConnections().iterator(); iter |
| .hasNext();) { |
| Link link = (Link) iter.next(); |
| Node source = link.getSource(); |
| if (source instanceof WorkBreakdownElementNode) { |
| if (source.isReadOnly()) |
| return errMsg_CanNotDelete; |
| } else if (source instanceof TypedNode) { |
| if (((TypedNode) source).getType() == TypedNode.SYNCH_BAR) |
| if (checkSyncBarIncomingLinks((TypedNode) source) != null) |
| return errMsg_CanNotDelete; |
| } |
| } |
| return null; |
| } |
| |
| /* |
| * Method to check if synchronization bar outgoing connection has any target |
| * is readonly. |
| */ |
| public static String checkSyncBarOutgoingLinks(TypedNode typedNode) { |
| for (Iterator iter = typedNode.getOutgoingConnections().iterator(); iter |
| .hasNext();) { |
| Link link = (Link) iter.next(); |
| Node target = link.getTarget(); |
| if (target instanceof WorkBreakdownElementNode) { |
| if (target.isReadOnly()) |
| return errMsg_CanNotDelete; |
| } else if (target instanceof TypedNode) { |
| if (((TypedNode) target).getType() == TypedNode.SYNCH_BAR) |
| if (checkSyncBarOutgoingLinks((TypedNode) target) != null) |
| return errMsg_CanNotDelete; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Check to see link is readonly. |
| */ |
| public static boolean isReadOnly(Link link) { |
| Node target = link.getTarget(); |
| Node source = link.getSource(); |
| if (target != null && target.getDiagram() instanceof ActivityDiagram) { |
| return checkDelete(link) != null; |
| } else if (target != null |
| && target.getDiagram() instanceof ActivityDetailDiagram) { |
| if ((source != null && source instanceof TaskNode && source |
| .isReadOnly()) |
| || (target instanceof TaskNode && target.isReadOnly())) |
| return true; |
| } |
| return false; |
| } |
| |
| } |
