| //------------------------------------------------------------------------------ |
| // 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.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.emf.common.notify.AdapterFactory; |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.impl.ENotificationImpl; |
| import org.eclipse.emf.edit.provider.ITreeItemContentProvider; |
| 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.TaskNode; |
| import org.eclipse.epf.diagram.model.WorkProductComposite; |
| import org.eclipse.epf.diagram.model.WorkProductDescriptorNode; |
| import org.eclipse.epf.diagram.model.util.GraphicalDataHelper; |
| import org.eclipse.epf.diagram.model.util.IAdapterFactoryFilter; |
| import org.eclipse.epf.library.edit.IFilter; |
| import org.eclipse.epf.library.edit.TngAdapterFactory; |
| import org.eclipse.epf.library.edit.util.ConfigurableComposedAdapterFactory; |
| import org.eclipse.epf.library.edit.util.Suppression; |
| import org.eclipse.epf.library.edit.util.TngUtil; |
| 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.TaskDescriptor; |
| import org.eclipse.epf.uma.UMASemanticModelBridge; |
| import org.eclipse.epf.uma.UmaFactory; |
| import org.eclipse.epf.uma.UmaPackage; |
| import org.eclipse.epf.uma.WorkProductDescriptor; |
| |
| |
| /** |
| * <!-- begin-user-doc --> An implementation of the model object '<em><b>Work Product Composite</b></em>'. |
| * <!-- end-user-doc --> |
| * <p> |
| * The following features are implemented: |
| * <ul> |
| * <li>{@link org.eclipse.epf.diagram.model.impl.WorkProductCompositeImpl#getType <em>Type</em>}</li> |
| * </ul> |
| * </p> |
| * |
| * @generated |
| */ |
| public class WorkProductCompositeImpl extends NodeContainerImpl implements |
| WorkProductComposite { |
| /** |
| * The default value of the '{@link #getType() <em>Type</em>}' attribute. |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @see #getType() |
| * @generated |
| * @ordered |
| */ |
| protected static final int TYPE_EDEFAULT = 0; |
| |
| /** |
| * The cached value of the '{@link #getType() <em>Type</em>}' attribute. |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @see #getType() |
| * @generated |
| * @ordered |
| */ |
| protected int type = TYPE_EDEFAULT; |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| protected WorkProductCompositeImpl() { |
| super(); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| protected EClass eStaticClass() { |
| return ModelPackage.Literals.WORK_PRODUCT_COMPOSITE; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| public int getType() { |
| return type; |
| } |
| |
| /** |
| * <!-- begin-user-doc --> <!-- end-user-doc --> |
| * @generated |
| */ |
| public void setType(int newType) { |
| int oldType = type; |
| type = newType; |
| if (eNotificationRequired()) |
| eNotify(new ENotificationImpl(this, Notification.SET, ModelPackage.WORK_PRODUCT_COMPOSITE__TYPE, oldType, type)); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| public Object eGet(int featureID, boolean resolve, boolean coreType) { |
| switch (featureID) { |
| case ModelPackage.WORK_PRODUCT_COMPOSITE__TYPE: |
| return new Integer(getType()); |
| } |
| 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.WORK_PRODUCT_COMPOSITE__TYPE: |
| setType(((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.WORK_PRODUCT_COMPOSITE__TYPE: |
| setType(TYPE_EDEFAULT); |
| return; |
| } |
| super.eUnset(featureID); |
| } |
| |
| /** |
| * <!-- begin-user-doc --> |
| * <!-- end-user-doc --> |
| * @generated |
| */ |
| @Override |
| public boolean eIsSet(int featureID) { |
| switch (featureID) { |
| case ModelPackage.WORK_PRODUCT_COMPOSITE__TYPE: |
| return type != TYPE_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(" (type: "); //$NON-NLS-1$ |
| result.append(type); |
| result.append(')'); |
| return result.toString(); |
| } |
| |
| private class TaskDescriptorAdapter extends TransactionalNodeLink { |
| protected void handleNotification(Notification msg) { |
| doHandleNotification(msg); |
| if(WorkProductCompositeImpl.this.getNodes().isEmpty()) { |
| // refresh diagram |
| // |
| org.eclipse.epf.diagram.model.Diagram diagram = getDiagram(); |
| if(diagram != null) { |
| diagram.getNodes().remove(WorkProductCompositeImpl.this); |
| diagram.setObject(diagram.getObject()); |
| } |
| } |
| } |
| |
| private void doHandleNotification(Notification msg) { |
| switch (msg.getFeatureID(TaskDescriptor.class)) { |
| case UmaPackage.TASK_DESCRIPTOR__OUTPUT: |
| switch (msg.getEventType()) { |
| case Notification.ADD: |
| Object obj = msg.getNewValue(); |
| if (obj != null && type == WorkProductComposite.OUTPUTS) { |
| addNode(obj); |
| } |
| return; |
| case Notification.REMOVE: |
| obj = msg.getOldValue(); |
| if (obj != null && type == WorkProductComposite.OUTPUTS) { |
| removeNode(obj); |
| } |
| return; |
| } |
| break; |
| case UmaPackage.TASK_DESCRIPTOR__MANDATORY_INPUT: |
| switch (msg.getEventType()) { |
| case Notification.ADD: |
| Object obj = msg.getNewValue(); |
| if (obj != null && type == WorkProductComposite.INPUTS) { |
| addNode(obj); |
| } |
| return; |
| case Notification.REMOVE: |
| obj = msg.getOldValue(); |
| if (obj != null && type == WorkProductComposite.INPUTS) { |
| removeNode(obj); |
| } |
| return; |
| } |
| break; |
| } |
| } |
| |
| } |
| |
| private IFilter getFilter() { |
| DiagramImpl diagram = (DiagramImpl) getDiagram(); |
| if (diagram.filter == null) { |
| ConfigurableComposedAdapterFactory adapterFactory = (ConfigurableComposedAdapterFactory) TngAdapterFactory.INSTANCE |
| .getPBS_ComposedAdapterFactory(); |
| return adapterFactory.getFilter(); |
| } else { |
| return diagram.filter; |
| } |
| } |
| public void setObject(Object newObject) { |
| |
| super.setObject(newObject); |
| populateNodes(newObject); |
| |
| } |
| |
| protected void basicSetObject(Object newObject) { |
| |
| super.basicSetObject(newObject); |
| |
| if(isGraphicalDataRequired()) { |
| // Set the Type information for workproduct composite. |
| if (type == TYPE_EDEFAULT) { |
| List list = graphNode.getList(UmaPackage.GRAPH_NODE__PROPERTY); |
| Property property = GraphicalDataHelper.getPropertyByKey(list, |
| GraphicalDataHelper.PROP_WORK_PRODUCT_COMPOSITE_TYPE); |
| if (property != null) { |
| property.setValue(property.getValue()); |
| list.add(property); |
| } |
| } else { |
| List list = graphNode.getList(UmaPackage.GRAPH_NODE__PROPERTY); |
| Property property = GraphicalDataHelper.getPropertyByKey(list, |
| GraphicalDataHelper.PROP_WORK_PRODUCT_COMPOSITE_TYPE); |
| if (property != null) { |
| property.setValue(new Integer(getType()).toString()); |
| list.add(property); |
| } |
| } |
| } |
| } |
| |
| private WorkProductDescriptorNode createWorkProductDescriptorNode(WorkProductDescriptor wpd) { |
| WorkProductDescriptorNode wpdNode = null; |
| for (Iterator iter = getNodes().iterator(); iter.hasNext();) { |
| Node node = (Node) iter.next(); |
| if(node instanceof WorkProductDescriptorNode && node.getLinkedElement() == wpd) { |
| wpdNode = (WorkProductDescriptorNode) node; |
| } |
| } |
| if(wpdNode == null) { |
| wpdNode = ModelFactory.eINSTANCE.createWorkProductDescriptorNode(); |
| wpdNode.setDiagram(getDiagram()); |
| } |
| wpdNode.setObject(wpd); |
| return wpdNode; |
| } |
| |
| public void populateNodes(Object newObject){ |
| if (newObject instanceof TaskDescriptor) { |
| List wplist = new ArrayList(); |
| if (getType() == WorkProductComposite.INPUTS) { |
| if (!((TaskDescriptor) newObject).getMandatoryInput().isEmpty()) |
| wplist.addAll(((TaskDescriptor) newObject) |
| .getMandatoryInput()); |
| } else { |
| if (!((TaskDescriptor) newObject).getOutput().isEmpty()) |
| wplist.addAll(((TaskDescriptor) newObject).getOutput()); |
| } |
| |
| IFilter filter = getFilter(); |
| Collection allElements = ((ActivityDetailDiagramImpl)getDiagram()) |
| .getAllBreakdownElements(false); |
| AdapterFactory adapterFactory = getAdapterFactory(); |
| |
| ArrayList nodes = new ArrayList(); |
| Suppression suppression = getDiagram().getSuppression(); |
| // Suppression suppression = new Suppression(TngUtil.getOwningProcess(getObject())); |
| for (Iterator iter = wplist.iterator(); iter.hasNext();) { |
| WorkProductDescriptor wpDescriptor = (WorkProductDescriptor) iter |
| .next(); |
| if (filter == null || filter.accept(wpDescriptor)) { |
| |
| Object wrapper = null; |
| // if(adapterFactory != null){ |
| // wrapper = adapterFactory.adapt(wpDescriptor, ITreeItemContentProvider.class); |
| // } |
| for (Iterator iterator = allElements.iterator(); iterator |
| .hasNext();) { |
| Object element = (Object) iterator.next(); |
| if(TngUtil.unwrap(element) == wpDescriptor){ |
| wrapper = element; |
| } |
| } |
| if(wrapper == null && adapterFactory != null){ |
| wrapper = adapterFactory.adapt(wpDescriptor, ITreeItemContentProvider.class); |
| } |
| if(wrapper == null){ |
| wrapper = wpDescriptor; |
| } |
| if (!suppression.isSuppressed(wrapper)) { |
| Node node = GraphicalDataHelper.findNode(this, |
| wpDescriptor); |
| if (node == null) { |
| node = createWorkProductDescriptorNode(wpDescriptor); |
| } |
| else { |
| // this will make sure that link between the node and linked element is established |
| // |
| node.setObject(wpDescriptor); |
| } |
| ((NamedNodeImpl) node).setItemProvider(allElements); |
| nodes.add(node); |
| } |
| } |
| } |
| |
| selectNodes(nodes); |
| } |
| } |
| |
| public void addNode(Collection collection) { |
| Collection nodes = new ArrayList(); |
| for (Iterator iter = collection.iterator(); iter.hasNext();) { |
| WorkProductDescriptor descriptor = (WorkProductDescriptor) iter |
| .next(); |
| addNode(nodes, descriptor); |
| } |
| |
| getNodes().addAll(nodes); |
| } |
| |
| public void removeNode(Object oldValue) { |
| Collection removedNodes = new HashSet(); |
| if (oldValue instanceof TaskDescriptor) { |
| Node node = findNode((ActivityDetailDiagram) getDiagram(), |
| getObject()); |
| getDiagram().getNodes().remove(node); |
| } |
| for (Iterator iter = nodes.iterator(); iter.hasNext();) { |
| Node node = (Node) iter.next(); |
| if (node.getObject() == oldValue) { |
| iter.remove(); |
| removedNodes.add(node); |
| } |
| } |
| // pushBackToDiagram(removedNodes); |
| } |
| |
| public void addNode(Object descriptor) { |
| addNode(getNodes(), descriptor); |
| } |
| |
| private void addNode(Collection nodes, Object descriptor) { |
| |
| if (descriptor instanceof TaskDescriptor) { |
| Node node = findNode((ActivityDetailDiagram) getDiagram(), |
| descriptor); |
| if (node == null) { |
| node = ((ActivityDetailDiagramImpl) getDiagram()) |
| .createWorkProductComposite( |
| (TaskDescriptor) descriptor, this.type); |
| getDiagram().getNodes().add(node); |
| } |
| } |
| if(descriptor instanceof WorkProductDescriptor){ |
| ActivityDetailDiagramImpl diagram = (ActivityDetailDiagramImpl) getDiagram(); |
| Node node = GraphicalDataHelper.findNode(this , |
| descriptor); |
| if (node == null) { |
| if (descriptor instanceof WorkProductDescriptor){ |
| node = diagram.createNode((WorkProductDescriptor) descriptor); |
| } |
| nodes.add(node); |
| } |
| } |
| } |
| |
| /** |
| * @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); |
| // } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.epf.diagram.model.impl.NodeImpl#getMethodElementAdapterType() |
| */ |
| public Class getMethodElementAdapterType() { |
| return TaskDescriptorAdapter.class; |
| } |
| |
| public Point getLocation() { |
| if (getType() == WorkProductComposite.INPUTS) { |
| return super.getLocation(); |
| } |
| if (getType() == WorkProductComposite.OUTPUTS) { |
| return super.getLocation(); |
| } else { |
| return new Point(-1, -1); |
| } |
| } |
| |
| public GraphNode getGraphNode(MethodElement methodElement) { |
| if(isGraphicalDataRequired()) { |
| if (getUMADiagram() == null) { |
| // new MethodElement |
| // |
| return createGraphNode(methodElement); |
| } |
| GraphNode node = findGraphNode(getUMADiagram(), methodElement); |
| if (node == null) { |
| node = createGraphNode(methodElement); |
| // createGraphConnectors(node, getUMADiagram()); |
| getUMADiagram().getContained().add(node); |
| } |
| 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()) { |
| |
| List list = element.getList(UmaPackage.GRAPH_NODE__PROPERTY); |
| Property property = GraphicalDataHelper.getPropertyByKey(list, |
| GraphicalDataHelper.PROP_WORK_PRODUCT_COMPOSITE_TYPE); |
| if (property != null) { |
| String typeString = property.getValue(); |
| if (typeString != null) { |
| if (getType() == new Integer(typeString).intValue()) |
| return element; |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| private GraphNode createGraphNode(MethodElement element) { |
| GraphNode graphNode = UmaFactory.eINSTANCE.createGraphNode(); |
| UMASemanticModelBridge modelBridge = UmaFactory.eINSTANCE |
| .createUMASemanticModelBridge(); |
| modelBridge.setElement(element); |
| graphNode.setSemanticModel(modelBridge); |
| org.eclipse.epf.uma.Point point = UmaFactory.eINSTANCE.createPoint(); |
| point.setX(new Double(-1)); |
| point.setY(new Double(-1)); |
| graphNode.setPosition(point); |
| org.eclipse.epf.uma.Dimension dim = UmaFactory.eINSTANCE.createDimension(); |
| dim.setWidth(new Double(-1)); |
| dim.setHeight(new Double(-1)); |
| graphNode.setSize(dim); |
| |
| // For setting type of WorkProductComposite |
| Property property = UmaFactory.eINSTANCE.createProperty(); |
| property.setKey(GraphicalDataHelper.PROP_WORK_PRODUCT_COMPOSITE_TYPE); |
| property.setValue(new Integer(getType()).toString()); //$NON-NLS-1$ |
| List list = new ArrayList(); |
| list.add(property); |
| graphNode.set(UmaPackage.GRAPH_NODE__PROPERTY, list); |
| return graphNode; |
| } |
| |
| public Node findNode(ActivityDetailDiagram diagram, Object object) { |
| for (Iterator iter = diagram.getNodes().iterator(); iter.hasNext();) { |
| Node element = (Node) iter.next(); |
| if (object == element.getObject() |
| && element instanceof WorkProductComposite) { |
| if (((WorkProductComposite) element).getType() == this.type) |
| return element; |
| } |
| } |
| return null; |
| } |
| |
| @Override |
| protected Object getMethodElementAdapter() { |
| if(methodElementAdapter == null) { |
| methodElementAdapter = new TaskDescriptorAdapter(); |
| } |
| return methodElementAdapter; |
| } |
| |
| private AdapterFactory getAdapterFactory(){ |
| AdapterFactory adapterFactory = null; |
| IFilter filter = getFilter(); |
| if (filter == null) { |
| adapterFactory = TngAdapterFactory.INSTANCE.getPBS_ComposedAdapterFactory(); |
| } else if (filter instanceof IAdapterFactoryFilter) { |
| adapterFactory = (ConfigurableComposedAdapterFactory) ((IAdapterFactoryFilter) filter) |
| .getWPBSAdapterFactory(); |
| } |
| return adapterFactory; |
| } |
| |
| private TaskNode taskNode; |
| |
| protected TaskNode getTaskNode() { |
| return taskNode; |
| } |
| |
| protected void setTaskNode(TaskNode taskNode) { |
| this.taskNode = taskNode; |
| } |
| |
| } // WorkProductCompositeImpl |