//------------------------------------------------------------------------------
// 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.model.impl;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import org.eclipse.emf.common.notify.Notification;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.impl.ENotificationImpl;
import org.eclipse.epf.diagram.model.ActivityDetailDiagram;
import org.eclipse.epf.diagram.model.ModelFactory;
import org.eclipse.epf.diagram.model.ModelPackage;
import org.eclipse.epf.diagram.model.Node;
import org.eclipse.epf.diagram.model.RoleNode;
import org.eclipse.epf.diagram.model.RoleTaskComposite;
import org.eclipse.epf.diagram.model.TaskNode;
import org.eclipse.epf.diagram.model.WorkProductComposite;
import org.eclipse.epf.diagram.model.util.GraphicalDataHelper;
import org.eclipse.epf.diagram.model.util.GraphicalDataManager;
import org.eclipse.epf.library.edit.util.TngUtil;
import org.eclipse.epf.uma.Activity;
import org.eclipse.epf.uma.Diagram;
import org.eclipse.epf.uma.GraphNode;
import org.eclipse.epf.uma.MethodElement;
import org.eclipse.epf.uma.Property;
import org.eclipse.epf.uma.RoleDescriptor;
import org.eclipse.epf.uma.TaskDescriptor;
import org.eclipse.epf.uma.UMASemanticModelBridge;
import org.eclipse.epf.uma.UmaPackage;
import org.eclipse.epf.uma.ecore.util.OppositeFeatureNotification;
import org.eclipse.epf.uma.util.AssociationHelper;
/**
* <!-- begin-user-doc --> An implementation of the model object '<em><b>Role Task Composite</b></em>'.
* <!-- end-user-doc -->
* <p>
* The following features are implemented:
* <ul>
* <li>{@link org.eclipse.epf.diagram.model.impl.RoleTaskCompositeImpl#getRowIndex <em>Row Index</em>}</li>
* </ul>
* </p>
*
* @generated
*/
public class RoleTaskCompositeImpl extends NodeContainerImpl implements
RoleTaskComposite {
/**
* The default value of the '{@link #getRowIndex() <em>Row Index</em>}' attribute.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @see #getRowIndex()
* @generated
* @ordered
*/
protected static final int ROW_INDEX_EDEFAULT = 0;
/**
* The cached value of the '{@link #getRowIndex() <em>Row Index</em>}' attribute.
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @see #getRowIndex()
* @generated
* @ordered
*/
protected int rowIndex = ROW_INDEX_EDEFAULT;
// private int rowIndex;
/**
* <!-- begin-user-doc --> <!-- end-user-doc -->
*/
protected RoleTaskCompositeImpl() {
super();
methodElementAdapter = new RoleDescriptorAdapter();
}
/**
* <!-- begin-user-doc --> <!-- end-user-doc -->
* @generated
*/
@Override
protected EClass eStaticClass() {
return ModelPackage.Literals.ROLE_TASK_COMPOSITE;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public int getRowIndex() {
return rowIndex;
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
public void setRowIndex(int newRowIndex) {
int oldRowIndex = rowIndex;
rowIndex = newRowIndex;
if (eNotificationRequired())
eNotify(new ENotificationImpl(this, Notification.SET, ModelPackage.ROLE_TASK_COMPOSITE__ROW_INDEX, oldRowIndex, rowIndex));
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public Object eGet(int featureID, boolean resolve, boolean coreType) {
switch (featureID) {
case ModelPackage.ROLE_TASK_COMPOSITE__ROW_INDEX:
return new Integer(getRowIndex());
}
return super.eGet(featureID, resolve, coreType);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public void eSet(int featureID, Object newValue) {
switch (featureID) {
case ModelPackage.ROLE_TASK_COMPOSITE__ROW_INDEX:
setRowIndex(((Integer)newValue).intValue());
return;
}
super.eSet(featureID, newValue);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public void eUnset(int featureID) {
switch (featureID) {
case ModelPackage.ROLE_TASK_COMPOSITE__ROW_INDEX:
setRowIndex(ROW_INDEX_EDEFAULT);
return;
}
super.eUnset(featureID);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public boolean eIsSet(int featureID) {
switch (featureID) {
case ModelPackage.ROLE_TASK_COMPOSITE__ROW_INDEX:
return rowIndex != ROW_INDEX_EDEFAULT;
}
return super.eIsSet(featureID);
}
/**
* <!-- begin-user-doc -->
* <!-- end-user-doc -->
* @generated
*/
@Override
public String toString() {
if (eIsProxy()) return super.toString();
StringBuffer result = new StringBuffer(super.toString());
result.append(" (rowIndex: "); //$NON-NLS-1$
result.append(rowIndex);
result.append(')');
return result.toString();
}
private static boolean contains(Collection mixedCollection, Object element) {
for (Iterator iter = mixedCollection.iterator(); iter.hasNext();) {
if( element == TngUtil.unwrap(iter.next()) ) {
return true;
}
}
return false;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.epf.diagram.model.impl.NodeImpl#setObject(java.lang.Object)
*/
public void setObject(Object newObject) {
super.setObject(newObject);
populateNodes(newObject);
}
public GraphNode getGraphNode(MethodElement methodElement) {
if(isGraphicalDataRequired()) {
if (getUMADiagram() == null) {
// new MethodElement
//
return GraphicalDataManager.getInstance().createGraphNode(methodElement);
}
GraphNode node = findGraphNode(getUMADiagram(), methodElement);
if (node == null) {
node = GraphicalDataManager.getInstance().createGraphNode(methodElement);
// createGraphConnectors(node, getUMADiagram());
getUMADiagram().getContained().add(node);
}
String autolayout = GraphicalDataHelper.getAutoLayoutFlag((ActivityDetailDiagram)getDiagram());
if(autolayout != null){
GraphicalDataHelper.createProperty(node, GraphicalDataHelper.PROP_INDEX, new Integer(rowIndex).toString());
}
return node;
}
return null;
}
public GraphNode findGraphNode(Diagram diagram, Object methodElement) {
for (Iterator iter = diagram.getContained().iterator(); iter.hasNext();) {
GraphNode element = (GraphNode) iter.next();
if (element.getSemanticModel() instanceof UMASemanticModelBridge
&& methodElement == ((UMASemanticModelBridge) element
.getSemanticModel()).getElement()) {
Property property = GraphicalDataHelper.findProperty(element, GraphicalDataHelper.PROP_INDEX);
if (property != null) {
String index = property.getValue();
if (index != null) {
if (getRowIndex() == new Integer(index).intValue())
return element;
}
}else{
return element;
}
}
}
return null;
}
// public GraphNode createGraphNode(MethodElement element) {
// GraphNode node = GraphicalDataManager.getInstance().createGraphNode(element);
// GraphicalDataHelper.createProperty(node,
// GraphicalDataHelper.PROP_INDEX, new Integer(rowIndex)
// .toString());
// return node;
// }
private class RoleDescriptorAdapter extends TransactionalNodeLink {
@Override
protected void handleNotification(Notification msg) {
if(msg instanceof OppositeFeatureNotification) {
Object feature = ((OppositeFeatureNotification)msg).getOppsiteFeature();
if(feature == AssociationHelper.RoleDescriptor_PrimaryTaskDescriptors) {
switch (msg.getEventType()) {
case Notification.ADD:
addNode((TaskDescriptor) msg.getNewValue());
break;
case Notification.REMOVE:
removeNode(msg.getOldValue());
break;
case Notification.ADD_MANY:
addNode((Collection) msg.getNewValue());
break;
case Notification.REMOVE_MANY:
removeNode((Collection) msg.getOldValue());
break;
}
return;
}
}
switch (msg.getFeatureID(Activity.class)) {
case UmaPackage.ACTIVITY__BREAKDOWN_ELEMENTS:
switch (msg.getEventType()) {
case Notification.MOVE:
// System.out.println("MOVEEEEEEED");
break;
}
break;
}
}
}
/**
* @param oldValue
*/
private void removeNode(Object oldValue) {
org.eclipse.epf.diagram.model.Diagram diagram = getDiagram();
if(diagram == null) {
System.err.println("RoleTaskCompositeImpl.removeNode(): [ERROR] no diagram"); //$NON-NLS-1$
}
Collection removedNodes = new HashSet();
for (Iterator iter = nodes.iterator(); iter.hasNext();) {
Node node = (Node) iter.next();
if (oldValue instanceof TaskDescriptor) {
if (node instanceof RoleNode) {
ActivityDetailDiagramImpl d = (ActivityDetailDiagramImpl)getDiagram();
List list = d.getRealizedPrimaryTaskDescriptors((RoleDescriptor) node.getObject());
if (list == null || list.size() < 1) {
iter.remove();
removedNodes.add(node);
}
}
}
if (node.getObject() == oldValue) {
iter.remove();
removedNodes.add(node);
if (oldValue instanceof TaskDescriptor) {
Node wpnode = GraphicalDataHelper.findNode(
(ActivityDetailDiagram) getDiagram(), oldValue);
getDiagram().getNodes().remove(wpnode);
wpnode = GraphicalDataHelper.findNode(
(ActivityDetailDiagram) getDiagram(), oldValue);
getDiagram().getNodes().remove(wpnode);
}
}
}
if (nodes.isEmpty()) {
getDiagram().getNodes().remove(this);
}
// pushBackToDiagram(removedNodes);
}
/**
* @param descriptor
*/
private void addNode(TaskDescriptor descriptor) {
addNode(getNodes(), descriptor);
}
private void addNode(Collection nodes, TaskDescriptor descriptor) {
if(descriptor.getSuperActivities() == null) {
return;
}
ActivityDetailDiagramImpl diagram = (ActivityDetailDiagramImpl) getDiagram();
Node node = GraphicalDataHelper.findNode(this,
descriptor, TaskNode.class);
if (node == null) {
node = diagram.createNode(descriptor);
if(node != null) {
int i = getNextIndex(getNodes());
if (node instanceof TaskNodeImpl) {
((TaskNodeImpl) node).doSetIndex(i + 1);
}
nodes.add(node);
Collection inputOutputNodes = new ArrayList();
diagram.createTaskInputOutputNodes(descriptor, inputOutputNodes);
if (!inputOutputNodes.isEmpty()) {
diagram.getNodes().addAll(inputOutputNodes);
diagram.populateLinks(inputOutputNodes, false);
}
}
}
}
/**
* @param oldValue
*/
private void removeNode(Collection elements) {
Collection nodes = new ArrayList();
for (Iterator iter = nodes.iterator(); iter.hasNext();) {
Node node = (Node) iter.next();
if (elements.contains(node.getObject())) {
nodes.add(node);
}
}
getNodes().removeAll(nodes);
// pushBackToDiagram(nodes);
}
/**
* @param newValue
*/
private void addNode(Collection elements) {
Collection nodes = new ArrayList();
for (Iterator iter = elements.iterator(); iter.hasNext();) {
TaskDescriptor descriptor = (TaskDescriptor) iter.next();
addNode(nodes, descriptor);
}
getNodes().addAll(nodes);
}
/*
* (non-Javadoc)
*
* @see org.eclipse.epf.diagram.model.impl.NodeImpl#getMethodElementAdapterType()
*/
public Class getMethodElementAdapterType() {
return RoleDescriptorAdapter.class;
}
/**
* @return
*/
private int getNextIndex(List nodes) {
int index = 0;
for(Iterator iterator = nodes.iterator(); iterator.hasNext();){
Object obj = iterator.next();
// if(obj instanceof Node){
// Node node = (Node)obj;
// //String temp = GraphicalDataHelper.findProperty(node.getGraphNode(), GraphicalDataHelper.PROP_INDEX).getValue();
// List list = node.getGraphNode().getList(UmaPackage.GRAPH_NODE__PROPERTY);
// if(list != null && !list.isEmpty()){
// for (int i = list.size() - 1; i > -1; i--) {
// Property prop = (Property) list.get(i);
// if (GraphicalDataHelper.PROP_INDEX.equals(prop.getKey())){
// int temp = Integer.parseInt(prop.getValue());
// if(temp > index ) index = temp;
// }
// }
// }
// }
if(obj instanceof TaskNodeImpl) {
int id = ((TaskNodeImpl)obj).doGetIndex();
if(id > index) {
index = id;
}
}
}
return index;
}
private static final Comparator comparator = new Comparator() {
public int compare(Object obj1, Object obj2) {
if (obj1 == obj2)
return 0;
if(obj1 instanceof TaskNodeImpl && obj2 instanceof TaskNodeImpl){
TaskNodeImpl node1 = (TaskNodeImpl)obj1;
TaskNodeImpl node2 = (TaskNodeImpl)obj2;
if(node1.doGetIndex() > node2.doGetIndex())
return 1;
}
return 0;
}
};
public void createTaskInputOutputNodes(TaskDescriptor descriptor, Collection nodes) {
Node newNode = null;
if (!descriptor.getMandatoryInput().isEmpty()) {
newNode = createWorkProductComposite(descriptor,
WorkProductComposite.INPUTS);
nodes.add(newNode);
}
if (!descriptor.getOutput().isEmpty()) {
newNode = createWorkProductComposite(descriptor,
WorkProductComposite.OUTPUTS);
nodes.add(newNode);
}
}
public WorkProductComposite createWorkProductComposite(
TaskDescriptor taskDescriptor, int type) {
WorkProductComposite workproductComposite = ModelFactory.eINSTANCE
.createWorkProductComposite();
workproductComposite.setUMAContainer(getGraphNode());
workproductComposite.setDiagram(getDiagram());
workproductComposite.setType(type);
workproductComposite.setObject(taskDescriptor);
return workproductComposite;
}
private TaskNode createTaskNode(TaskDescriptor td) {
TaskNode taskNode = null;
for (Iterator iter = getNodes().iterator(); iter.hasNext();) {
Node node = (Node) iter.next();
if(node instanceof TaskNode) {
TaskNode tn = (TaskNode) node;
if(tn.getLinkedElement() == td) {
taskNode = tn;
break;
}
}
}
if(taskNode == null) {
taskNode = ModelFactory.eINSTANCE.createTaskNode();
taskNode.setDiagram(getDiagram());
}
taskNode.setObject(td);
return taskNode;
}
private RoleNode createRoleNode(RoleDescriptor rd) {
RoleNode roleNode = null;
for (Iterator iter = getNodes().iterator(); iter.hasNext();) {
Node node = (Node) iter.next();
if(node instanceof RoleNode) {
RoleNode rn = (RoleNode) node;
if(rn.getLinkedElement() == rd) {
roleNode = rn;
break;
}
}
}
if(roleNode == null) {
roleNode = ModelFactory.eINSTANCE.createRoleNode();
roleNode.setDiagram(getDiagram());
roleNode.setObject(rd);
}
return roleNode;
}
public void populateNodes(Object newObject){
if (newObject instanceof RoleDescriptor) {
RoleDescriptor roleDescriptor = (RoleDescriptor) newObject;
ActivityDetailDiagramImpl diagram = (ActivityDetailDiagramImpl) getDiagram();
Collection allElements = diagram.getAllBreakdownElements(true);
List taskNodes = new ArrayList();
List primaryTaskDescriptors = AssociationHelper.getPrimaryTaskDescriptors(roleDescriptor);
if (!primaryTaskDescriptors.isEmpty()) { // overriding
List taskDescriptors = new ArrayList();
taskDescriptors.addAll(primaryTaskDescriptors);
HashSet selectedDescriptors = new HashSet();
boolean autoLayout = ((ActivityDetailDiagramImpl)getDiagram()).isAutoLayout();
if(autoLayout) {
int index = 0;
int rowTasksCount = 0;
int startCount = 0;
for (Iterator iter = allElements.iterator(); iter.hasNext();) {
Object obj = iter.next();
obj = TngUtil.unwrap(obj);
if (obj instanceof TaskDescriptor
&& TngUtil.contains(taskDescriptors, obj)) {
TaskDescriptor taskDescriptor = (TaskDescriptor) obj;
if(startCount < rowIndex * GraphicalDataHelper.getTasksPerRow()){
startCount++;
} else {
if (!selectedDescriptors
.contains(taskDescriptor)) {
selectedDescriptors.add(taskDescriptor);
Node node = GraphicalDataHelper.findNode(
this, taskDescriptor,
TaskNode.class);
if (node == null) {
// node = createTaskNode(taskDescriptor,
// index, allElements);
node = createTaskNode(taskDescriptor);
TaskNodeImpl tn = (TaskNodeImpl) node;
if (autoLayout || tn.doGetIndex() == -1) {
tn.doSetIndex(index);
// index++;
}
//return node;
}
else {
// this will make sure that link between the node and linked element is established
//
node.setObject(taskDescriptor);
}
((NamedNodeImpl) node).setItemProvider(allElements);
if (rowTasksCount < GraphicalDataHelper
.getTasksPerRow()) {
taskNodes.add(node);
if(node instanceof TaskNode){
((TaskNode)node).setIndex(index);
index++;
}
rowTasksCount++;
} else {
break;
}
}
}
}
}
// Sort the taskNode based on their index if autolayout is
// false
if (!autoLayout) {
Collections.sort(taskNodes, comparator);
}
} else {
List oldTaskDescriptors = new ArrayList();
Diagram umaDiagram = getUMADiagram();
if(umaDiagram != null) {
// Lame way of doing this, to fix a defect of 1.0 to 1.0.1 migration
List graphNodes = umaDiagram.getContained();
for (Iterator iter = graphNodes.iterator(); iter.hasNext();) {
GraphNode element = (GraphNode) iter.next();
Object bridge = element.getSemanticModel();
if(bridge instanceof UMASemanticModelBridge){
Object taskObject = ((UMASemanticModelBridge)bridge).getElement();
List list = element.getList(UmaPackage.GRAPH_NODE__PROPERTY);
Property property = GraphicalDataHelper.getPropertyByKey(list,
GraphicalDataHelper.PROP_WORK_PRODUCT_COMPOSITE_TYPE);
if (taskDescriptors.contains(taskObject) && property == null) {
oldTaskDescriptors.add(taskObject);
}
}
}
}
else {
for (Iterator iter = getNodes().iterator(); iter
.hasNext();) {
Node node = (Node) iter.next();
if(node.getLinkedElement() instanceof TaskDescriptor) {
oldTaskDescriptors.add(node.getLinkedElement());
}
}
}
for (Iterator iter = oldTaskDescriptors.iterator(); iter.hasNext();) {
TaskDescriptor taskDescriptor = (TaskDescriptor) iter.next();
// eliminate descriptor that is duplicate, suppressed or filtered out
//
if(!selectedDescriptors.contains(taskDescriptor)
&& contains(allElements, taskDescriptor) // make sure that task descriptor is of the owning activity
) {
selectedDescriptors.add(taskDescriptor);
Node node = GraphicalDataHelper.findNode(getDiagram(),
taskDescriptor, TaskNode.class);
if (node == null) {
node = createTaskNode(taskDescriptor);
((NamedNodeImpl) node).setItemProvider(allElements);
}
taskNodes.add(node);
}
}
}
}
if(!taskNodes.isEmpty()) {
// add role node
//
NamedNodeImpl namedNode = ((NamedNodeImpl) createRoleNode(roleDescriptor));
namedNode.visible = true;
namedNode.setItemProvider(allElements);
getNodes().add(namedNode);
taskNodes.add(namedNode);
}
selectNodes(taskNodes);
}
}
// public Node createTaskNode(TaskDescriptor taskDescriptor, int index, Collection allElements) {
// Node node = ModelFactory.eINSTANCE.createTaskNode();
// node.setDiagram(getDiagram());
// node.setObject(taskDescriptor);
// ((NamedNodeImpl) node).setItemProvider(allElements);
// if (GraphicalDataHelper.findProperty(node.getGraphNode(),
// GraphicalDataHelper.PROP_INDEX) == null
// || GraphicalDataHelper
// .isAutoLayout((ActivityDetailDiagram) getDiagram())) {
// GraphicalDataHelper.createProperty(node.getGraphNode(),
// GraphicalDataHelper.PROP_INDEX, new Integer(index)
// .toString());
// index++;
// }
// return node;
// }
} // RoleTaskCompositeImpl