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