| //------------------------------------------------------------------------------ |
| // 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.diagram.wpdd.edit.policies; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.LinkedList; |
| import java.util.List; |
| import java.util.Map; |
| |
| import org.eclipse.core.runtime.IAdaptable; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.epf.diagram.core.part.util.DiagramEditorUtil; |
| import org.eclipse.epf.diagram.model.Link; |
| import org.eclipse.epf.diagram.model.ModelPackage; |
| import org.eclipse.epf.diagram.model.Node; |
| import org.eclipse.epf.diagram.model.NodeContainer; |
| import org.eclipse.epf.diagram.model.WorkProductDependencyDiagram; |
| import org.eclipse.epf.diagram.wpdd.edit.parts.LinkEditPart; |
| import org.eclipse.epf.diagram.wpdd.edit.parts.WorkProductDependencyDiagramEditPart; |
| import org.eclipse.epf.diagram.wpdd.edit.parts.WorkProductNodeEditPart; |
| import org.eclipse.epf.diagram.wpdd.part.DiagramVisualIDRegistry; |
| import org.eclipse.epf.diagram.wpdd.providers.DiagramElementTypes; |
| import org.eclipse.gef.EditPart; |
| import org.eclipse.gef.commands.Command; |
| import org.eclipse.gmf.runtime.diagram.core.util.ViewUtil; |
| import org.eclipse.gmf.runtime.diagram.ui.commands.DeferredLayoutCommand; |
| import org.eclipse.gmf.runtime.diagram.ui.commands.ICommandProxy; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.DiagramEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; |
| import org.eclipse.gmf.runtime.diagram.ui.editpolicies.CanonicalConnectionEditPolicy; |
| import org.eclipse.gmf.runtime.diagram.ui.requests.CreateConnectionViewRequest; |
| import org.eclipse.gmf.runtime.diagram.ui.requests.RequestConstants; |
| import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter; |
| import org.eclipse.gmf.runtime.emf.type.core.IElementType; |
| import org.eclipse.gmf.runtime.notation.Diagram; |
| import org.eclipse.gmf.runtime.notation.Edge; |
| import org.eclipse.gmf.runtime.notation.View; |
| |
| /** |
| * @generated |
| */ |
| public class WorkProductDependencyDiagramCanonicalEditPolicy extends |
| CanonicalConnectionEditPolicy { |
| |
| @Override |
| public EObject getSemanticHost() { |
| return host().getModel() != null ? super.getSemanticHost() : null; |
| } |
| |
| @Override |
| protected void refreshOnActivate() { |
| super.refreshOnActivate(); |
| |
| EditPart ep = getHost(); |
| if(ep instanceof DiagramEditPart) { |
| DiagramEditorUtil.initializeOnActivate((DiagramEditPart) ep); |
| } |
| } |
| |
| /** |
| * @generated |
| */ |
| protected List getSemanticChildrenList() { |
| List result = new LinkedList(); |
| EObject modelObject = ((View) getHost().getModel()).getElement(); |
| View viewObject = (View) getHost().getModel(); |
| EObject nextValue; |
| int nodeVID; |
| for (Iterator values = ((NodeContainer) modelObject).getNodes() |
| .iterator(); values.hasNext();) { |
| nextValue = (EObject) values.next(); |
| nodeVID = DiagramVisualIDRegistry.getNodeVisualID(viewObject, |
| nextValue); |
| if (WorkProductNodeEditPart.VISUAL_ID == nodeVID) { |
| result.add(nextValue); |
| } |
| } |
| return result; |
| } |
| |
| /** |
| * @modified |
| */ |
| protected boolean shouldDeleteView(View view) { |
| return view.isSetElement() |
| && view.getElement() != null |
| && (view.getElement().eIsProxy() || view.getElement() instanceof Node); |
| } |
| |
| /** |
| * @generated |
| */ |
| protected String getDefaultFactoryHint() { |
| return null; |
| } |
| |
| /** |
| * @modified |
| */ |
| protected List getSemanticConnectionsList() { |
| List connections = new ArrayList(); |
| WorkProductDependencyDiagram diagram = (WorkProductDependencyDiagram) ((View) getHost() |
| .getModel()).getElement(); |
| for (Iterator iter = diagram.getNodes().iterator(); iter.hasNext();) { |
| Node node = (Node) iter.next(); |
| connections.addAll(node.getOutgoingConnections()); |
| } |
| return connections; |
| } |
| |
| /** |
| * @modified |
| */ |
| protected EObject getSourceElement(EObject relationship) { |
| if (relationship instanceof Link) { |
| return ((Link) relationship).getSource(); |
| } |
| return null; |
| } |
| |
| /** |
| * @modified |
| */ |
| protected EObject getTargetElement(EObject relationship) { |
| if (relationship instanceof Link) { |
| return ((Link) relationship).getTarget(); |
| } |
| return null; |
| } |
| |
| /** |
| * @modified |
| */ |
| protected boolean shouldIncludeConnection(Edge connector, |
| Collection children) { |
| return super.shouldIncludeConnection(connector, children); |
| } |
| |
| /** |
| * @generated |
| */ |
| protected void refreshSemantic() { |
| List createdViews = new LinkedList(); |
| createdViews.addAll(refreshSemanticChildren()); |
| List createdConnectionViews = new LinkedList(); |
| createdConnectionViews.addAll(refreshSemanticConnections()); |
| createdConnectionViews.addAll(refreshConnections()); |
| |
| if (createdViews.size() > 1) { |
| // perform a layout of the container |
| DeferredLayoutCommand layoutCmd = new DeferredLayoutCommand(host() |
| .getEditingDomain(), createdViews, host()); |
| executeCommand(new ICommandProxy(layoutCmd)); |
| } |
| |
| createdViews.addAll(createdConnectionViews); |
| makeViewsImmutable(createdViews); |
| } |
| |
| /** |
| * @generated |
| */ |
| private Collection myLinkDescriptors = new LinkedList(); |
| |
| /** |
| * @generated |
| */ |
| private Map myEObject2ViewMap = new HashMap(); |
| |
| /** |
| * @generated |
| */ |
| private Collection refreshConnections() { |
| try { |
| collectAllLinks(getDiagram()); |
| Collection existingLinks = new LinkedList(getDiagram().getEdges()); |
| for (Iterator diagramLinks = existingLinks.iterator(); diagramLinks |
| .hasNext();) { |
| Edge nextDiagramLink = (Edge) diagramLinks.next(); |
| EObject diagramLinkObject = nextDiagramLink.getElement(); |
| EObject diagramLinkSrc = nextDiagramLink.getSource() |
| .getElement(); |
| EObject diagramLinkDst = nextDiagramLink.getTarget() |
| .getElement(); |
| int diagramLinkVisualID = DiagramVisualIDRegistry |
| .getVisualID(nextDiagramLink); |
| for (Iterator modelLinkDescriptors = myLinkDescriptors |
| .iterator(); modelLinkDescriptors.hasNext();) { |
| LinkDescriptor nextLinkDescriptor = (LinkDescriptor) modelLinkDescriptors |
| .next(); |
| if (diagramLinkObject == nextLinkDescriptor |
| .getLinkElement() |
| && diagramLinkSrc == nextLinkDescriptor.getSource() |
| && diagramLinkDst == nextLinkDescriptor |
| .getDestination() |
| && diagramLinkVisualID == nextLinkDescriptor |
| .getVisualID()) { |
| diagramLinks.remove(); |
| modelLinkDescriptors.remove(); |
| } |
| } |
| } |
| deleteViews(existingLinks.iterator()); |
| return createConnections(myLinkDescriptors); |
| } finally { |
| myLinkDescriptors.clear(); |
| myEObject2ViewMap.clear(); |
| } |
| } |
| |
| /** |
| * @generated |
| */ |
| private void collectAllLinks(View view) { |
| EObject modelElement = view.getElement(); |
| int diagramElementVisualID = DiagramVisualIDRegistry.getVisualID(view); |
| switch (diagramElementVisualID) { |
| case WorkProductNodeEditPart.VISUAL_ID: |
| case WorkProductDependencyDiagramEditPart.VISUAL_ID: { |
| myEObject2ViewMap.put(modelElement, view); |
| storeLinks(modelElement, getDiagram()); |
| } |
| default: { |
| } |
| for (Iterator children = view.getChildren().iterator(); children |
| .hasNext();) { |
| View childView = (View) children.next(); |
| collectAllLinks(childView); |
| } |
| } |
| } |
| |
| /** |
| * @generated |
| */ |
| private Collection createConnections(Collection linkDescriptors) { |
| if (linkDescriptors.isEmpty()) { |
| return Collections.EMPTY_LIST; |
| } |
| List adapters = new LinkedList(); |
| for (Iterator linkDescriptorsIterator = linkDescriptors.iterator(); linkDescriptorsIterator |
| .hasNext();) { |
| final LinkDescriptor nextLinkDescriptor = (LinkDescriptor) linkDescriptorsIterator |
| .next(); |
| EditPart sourceEditPart = getEditPartFor(nextLinkDescriptor |
| .getSource()); |
| EditPart targetEditPart = getEditPartFor(nextLinkDescriptor |
| .getDestination()); |
| if (sourceEditPart == null || targetEditPart == null) { |
| continue; |
| } |
| CreateConnectionViewRequest.ConnectionViewDescriptor descriptor = new CreateConnectionViewRequest.ConnectionViewDescriptor( |
| nextLinkDescriptor.getSemanticAdapter(), null, |
| ViewUtil.APPEND, false, ((IGraphicalEditPart) getHost()) |
| .getDiagramPreferencesHint()); |
| CreateConnectionViewRequest ccr = new CreateConnectionViewRequest( |
| descriptor); |
| ccr.setType(RequestConstants.REQ_CONNECTION_START); |
| ccr.setSourceEditPart(sourceEditPart); |
| sourceEditPart.getCommand(ccr); |
| ccr.setTargetEditPart(targetEditPart); |
| ccr.setType(RequestConstants.REQ_CONNECTION_END); |
| Command cmd = targetEditPart.getCommand(ccr); |
| if (cmd != null && cmd.canExecute()) { |
| executeCommand(cmd); |
| IAdaptable viewAdapter = (IAdaptable) ccr.getNewObject(); |
| if (viewAdapter != null) { |
| adapters.add(viewAdapter); |
| } |
| } |
| } |
| return adapters; |
| } |
| |
| /** |
| * @generated |
| */ |
| private EditPart getEditPartFor(EObject modelElement) { |
| View view = (View) myEObject2ViewMap.get(modelElement); |
| if (view != null) { |
| return (EditPart) getHost().getViewer().getEditPartRegistry().get( |
| view); |
| } |
| return null; |
| } |
| |
| /** |
| *@generated |
| */ |
| private void storeLinks(EObject container, Diagram diagram) { |
| EClass containerMetaclass = container.eClass(); |
| storeFeatureModelFacetLinks(container, containerMetaclass, diagram); |
| storeTypeModelFacetLinks(container, containerMetaclass); |
| } |
| |
| /** |
| * @generated |
| */ |
| private void storeTypeModelFacetLinks(EObject container, |
| EClass containerMetaclass) { |
| storeTypeModelFacetLinks_Link_3001(container, containerMetaclass); |
| } |
| |
| /** |
| * @generated |
| */ |
| private void storeTypeModelFacetLinks_Link_3001(EObject container, |
| EClass containerMetaclass) { |
| if (ModelPackage.eINSTANCE.getNode().isSuperTypeOf(containerMetaclass)) { |
| for (Iterator values = ((Node) container).getOutgoingConnections() |
| .iterator(); values.hasNext();) { |
| EObject nextValue = ((EObject) values.next()); |
| int linkVID = DiagramVisualIDRegistry |
| .getLinkWithClassVisualID(nextValue); |
| if (LinkEditPart.VISUAL_ID == linkVID) { |
| Object structuralFeatureResult = ((Link) nextValue) |
| .getTarget(); |
| if (structuralFeatureResult instanceof EObject) { |
| EObject dst = (EObject) structuralFeatureResult; |
| structuralFeatureResult = ((Link) nextValue) |
| .getSource(); |
| if (structuralFeatureResult instanceof EObject) { |
| EObject src = (EObject) structuralFeatureResult; |
| myLinkDescriptors.add(new LinkDescriptor(src, dst, |
| nextValue, DiagramElementTypes.Link_3001, |
| linkVID)); |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| /** |
| *@generated |
| */ |
| private void storeFeatureModelFacetLinks(EObject container, |
| EClass containerMetaclass, Diagram diagram) { |
| |
| } |
| |
| /** |
| * @generated |
| */ |
| private Diagram getDiagram() { |
| return ((View) getHost().getModel()).getDiagram(); |
| } |
| |
| /** |
| * @generated |
| */ |
| private class LinkDescriptor { |
| |
| /** |
| * @generated |
| */ |
| private EObject mySource; |
| |
| /** |
| * @generated |
| */ |
| private EObject myDestination; |
| |
| /** |
| * @generated |
| */ |
| private EObject myLinkElement; |
| |
| /** |
| * @generated |
| */ |
| private int myVisualID; |
| |
| /** |
| * @generated |
| */ |
| private IAdaptable mySemanticAdapter; |
| |
| /** |
| * @generated |
| */ |
| protected LinkDescriptor(EObject source, EObject destination, |
| EObject linkElement, IElementType elementType, int linkVID) { |
| this(source, destination, linkVID); |
| myLinkElement = linkElement; |
| final IElementType elementTypeCopy = elementType; |
| mySemanticAdapter = new EObjectAdapter(linkElement) { |
| public Object getAdapter(Class adapter) { |
| if (IElementType.class.equals(adapter)) { |
| return elementTypeCopy; |
| } |
| return super.getAdapter(adapter); |
| } |
| }; |
| } |
| |
| /** |
| * @generated |
| */ |
| protected LinkDescriptor(EObject source, EObject destination, |
| IElementType elementType, int linkVID) { |
| this(source, destination, linkVID); |
| myLinkElement = null; |
| final IElementType elementTypeCopy = elementType; |
| mySemanticAdapter = new IAdaptable() { |
| public Object getAdapter(Class adapter) { |
| if (IElementType.class.equals(adapter)) { |
| return elementTypeCopy; |
| } |
| return null; |
| } |
| }; |
| } |
| |
| /** |
| * @generated |
| */ |
| private LinkDescriptor(EObject source, EObject destination, int linkVID) { |
| mySource = source; |
| myDestination = destination; |
| myVisualID = linkVID; |
| } |
| |
| /** |
| * @generated |
| */ |
| protected EObject getSource() { |
| return mySource; |
| } |
| |
| /** |
| * @generated |
| */ |
| protected EObject getDestination() { |
| return myDestination; |
| } |
| |
| /** |
| * @generated |
| */ |
| protected EObject getLinkElement() { |
| return myLinkElement; |
| } |
| |
| /** |
| * @generated |
| */ |
| protected int getVisualID() { |
| return myVisualID; |
| } |
| |
| /** |
| * @generated |
| */ |
| protected IAdaptable getSemanticAdapter() { |
| return mySemanticAdapter; |
| } |
| } |
| |
| } |