//------------------------------------------------------------------------------
// 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;
}
}