/******************************************************************************* * Copyright (c) 2006-2012 * Software Technology Group, Dresden University of Technology * DevBoost GmbH, Berlin, Amtsgericht Charlottenburg, HRB 140026 * * 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: * Software Technology Group - TU Dresden, Germany; * DevBoost GmbH - Berlin, Germany * - initial API and implementation ******************************************************************************/ package org.reuseware.coconut.compositionprogram.diagram.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.EObject; import org.eclipse.emf.ecore.EStructuralFeature; 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.commands.SetViewMutabilityCommand; import org.eclipse.gmf.runtime.diagram.ui.editparts.IGraphicalEditPart; import org.eclipse.gmf.runtime.diagram.ui.editpolicies.CanonicalEditPolicy; import org.eclipse.gmf.runtime.diagram.ui.requests.CreateConnectionViewRequest; import org.eclipse.gmf.runtime.diagram.ui.requests.CreateViewRequest; import org.eclipse.gmf.runtime.diagram.ui.requests.RequestConstants; import org.eclipse.gmf.runtime.emf.core.util.EObjectAdapter; 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.reuseware.coconut.compositionprogram.CompositionprogramPackage; import org.reuseware.coconut.compositionprogram.diagram.edit.parts.CompositionLinkEditPart; import org.reuseware.coconut.compositionprogram.diagram.edit.parts.CompositionProgramEditPart; import org.reuseware.coconut.compositionprogram.diagram.edit.parts.FragmentInstanceEditPart; import org.reuseware.coconut.compositionprogram.diagram.edit.parts.PortInstanceEditPart; import org.reuseware.coconut.compositionprogram.diagram.part.CompositionprogramDiagramUpdater; import org.reuseware.coconut.compositionprogram.diagram.part.CompositionprogramLinkDescriptor; import org.reuseware.coconut.compositionprogram.diagram.part.CompositionprogramNodeDescriptor; import org.reuseware.coconut.compositionprogram.diagram.part.CompositionprogramVisualIDRegistry; /** * @generated */ public class CompositionProgramCanonicalEditPolicy extends CanonicalEditPolicy { /** * @generated */ protected EStructuralFeature getFeatureToSynchronize() { return CompositionprogramPackage.eINSTANCE .getCompositionProgram_FragmentInstances(); } /** * @generated */ @SuppressWarnings("rawtypes") protected List getSemanticChildrenList() { View viewObject = (View) getHost().getModel(); LinkedList<EObject> result = new LinkedList<EObject>(); List<CompositionprogramNodeDescriptor> childDescriptors = CompositionprogramDiagramUpdater .getCompositionProgram_1000SemanticChildren(viewObject); for (CompositionprogramNodeDescriptor d : childDescriptors) { result.add(d.getModelElement()); } return result; } /** * @generated */ protected boolean isOrphaned(Collection<EObject> semanticChildren, final View view) { return isMyDiagramElement(view) && !semanticChildren.contains(view.getElement()); } /** * @generated */ private boolean isMyDiagramElement(View view) { return FragmentInstanceEditPart.VISUAL_ID == CompositionprogramVisualIDRegistry .getVisualID(view); } /** * @generated */ protected void refreshSemantic() { if (resolveSemanticElement() == null) { return; } LinkedList<IAdaptable> createdViews = new LinkedList<IAdaptable>(); List<CompositionprogramNodeDescriptor> childDescriptors = CompositionprogramDiagramUpdater .getCompositionProgram_1000SemanticChildren((View) getHost() .getModel()); LinkedList<View> orphaned = new LinkedList<View>(); // we care to check only views we recognize as ours LinkedList<View> knownViewChildren = new LinkedList<View>(); for (View v : getViewChildren()) { if (isMyDiagramElement(v)) { knownViewChildren.add(v); } } // alternative to #cleanCanonicalSemanticChildren(getViewChildren(), semanticChildren) // // iteration happens over list of desired semantic elements, trying to find best matching View, while original CEP // iterates views, potentially losing view (size/bounds) information - i.e. if there are few views to reference same EObject, only last one // to answer isOrphaned == true will be used for the domain element representation, see #cleanCanonicalSemanticChildren() for (Iterator<CompositionprogramNodeDescriptor> descriptorsIterator = childDescriptors .iterator(); descriptorsIterator.hasNext();) { CompositionprogramNodeDescriptor next = descriptorsIterator.next(); String hint = CompositionprogramVisualIDRegistry.getType(next .getVisualID()); LinkedList<View> perfectMatch = new LinkedList<View>(); // both semanticElement and hint match that of NodeDescriptor for (View childView : getViewChildren()) { EObject semanticElement = childView.getElement(); if (next.getModelElement().equals(semanticElement)) { if (hint.equals(childView.getType())) { perfectMatch.add(childView); // actually, can stop iteration over view children here, but // may want to use not the first view but last one as a 'real' match (the way original CEP does // with its trick with viewToSemanticMap inside #cleanCanonicalSemanticChildren } } } if (perfectMatch.size() > 0) { descriptorsIterator.remove(); // precise match found no need to create anything for the NodeDescriptor // use only one view (first or last?), keep rest as orphaned for further consideration knownViewChildren.remove(perfectMatch.getFirst()); } } // those left in knownViewChildren are subject to removal - they are our diagram elements we didn't find match to, // or those we have potential matches to, and thus need to be recreated, preserving size/location information. orphaned.addAll(knownViewChildren); // ArrayList<CreateViewRequest.ViewDescriptor> viewDescriptors = new ArrayList<CreateViewRequest.ViewDescriptor>( childDescriptors.size()); for (CompositionprogramNodeDescriptor next : childDescriptors) { String hint = CompositionprogramVisualIDRegistry.getType(next .getVisualID()); IAdaptable elementAdapter = new CanonicalElementAdapter( next.getModelElement(), hint); CreateViewRequest.ViewDescriptor descriptor = new CreateViewRequest.ViewDescriptor( elementAdapter, Node.class, hint, ViewUtil.APPEND, false, host().getDiagramPreferencesHint()); viewDescriptors.add(descriptor); } boolean changed = deleteViews(orphaned.iterator()); // CreateViewRequest request = getCreateViewRequest(viewDescriptors); Command cmd = getCreateViewCommand(request); if (cmd != null && cmd.canExecute()) { SetViewMutabilityCommand.makeMutable( new EObjectAdapter(host().getNotationView())).execute(); executeCommand(cmd); @SuppressWarnings("unchecked") List<IAdaptable> nl = (List<IAdaptable>) request.getNewObject(); createdViews.addAll(nl); } if (changed || createdViews.size() > 0) { postProcessRefreshSemantic(createdViews); } Collection<IAdaptable> createdConnectionViews = 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<IAdaptable> refreshConnections() { Map<EObject, View> domain2NotationMap = new HashMap<EObject, View>(); Collection<CompositionprogramLinkDescriptor> linkDescriptors = collectAllLinks( getDiagram(), domain2NotationMap); Collection existingLinks = new LinkedList(getDiagram().getEdges()); for (Iterator linksIterator = existingLinks.iterator(); linksIterator .hasNext();) { Edge nextDiagramLink = (Edge) linksIterator.next(); int diagramLinkVisualID = CompositionprogramVisualIDRegistry .getVisualID(nextDiagramLink); if (diagramLinkVisualID == -1) { if (nextDiagramLink.getSource() != null && nextDiagramLink.getTarget() != null) { linksIterator.remove(); } continue; } EObject diagramLinkObject = nextDiagramLink.getElement(); EObject diagramLinkSrc = nextDiagramLink.getSource().getElement(); EObject diagramLinkDst = nextDiagramLink.getTarget().getElement(); for (Iterator<CompositionprogramLinkDescriptor> linkDescriptorsIterator = linkDescriptors .iterator(); linkDescriptorsIterator.hasNext();) { CompositionprogramLinkDescriptor nextLinkDescriptor = linkDescriptorsIterator .next(); if (diagramLinkObject == nextLinkDescriptor.getModelElement() && diagramLinkSrc == nextLinkDescriptor.getSource() && diagramLinkDst == nextLinkDescriptor .getDestination() && diagramLinkVisualID == nextLinkDescriptor .getVisualID()) { linksIterator.remove(); linkDescriptorsIterator.remove(); break; } } } deleteViews(existingLinks.iterator()); return createConnections(linkDescriptors, domain2NotationMap); } /** * @generated */ private Collection<CompositionprogramLinkDescriptor> collectAllLinks( View view, Map<EObject, View> domain2NotationMap) { if (!CompositionProgramEditPart.MODEL_ID .equals(CompositionprogramVisualIDRegistry.getModelID(view))) { return Collections.emptyList(); } LinkedList<CompositionprogramLinkDescriptor> result = new LinkedList<CompositionprogramLinkDescriptor>(); switch (CompositionprogramVisualIDRegistry.getVisualID(view)) { case CompositionProgramEditPart.VISUAL_ID: { if (!domain2NotationMap.containsKey(view.getElement())) { result.addAll(CompositionprogramDiagramUpdater .getCompositionProgram_1000ContainedLinks(view)); } if (!domain2NotationMap.containsKey(view.getElement()) || view.getEAnnotation("Shortcut") == null) { //$NON-NLS-1$ domain2NotationMap.put(view.getElement(), view); } break; } case FragmentInstanceEditPart.VISUAL_ID: { if (!domain2NotationMap.containsKey(view.getElement())) { result.addAll(CompositionprogramDiagramUpdater .getFragmentInstance_2001ContainedLinks(view)); } if (!domain2NotationMap.containsKey(view.getElement()) || view.getEAnnotation("Shortcut") == null) { //$NON-NLS-1$ domain2NotationMap.put(view.getElement(), view); } break; } case PortInstanceEditPart.VISUAL_ID: { if (!domain2NotationMap.containsKey(view.getElement())) { result.addAll(CompositionprogramDiagramUpdater .getPortInstance_3001ContainedLinks(view)); } if (!domain2NotationMap.containsKey(view.getElement()) || view.getEAnnotation("Shortcut") == null) { //$NON-NLS-1$ domain2NotationMap.put(view.getElement(), view); } break; } case CompositionLinkEditPart.VISUAL_ID: { if (!domain2NotationMap.containsKey(view.getElement())) { result.addAll(CompositionprogramDiagramUpdater .getCompositionLink_4001ContainedLinks(view)); } if (!domain2NotationMap.containsKey(view.getElement()) || view.getEAnnotation("Shortcut") == null) { //$NON-NLS-1$ domain2NotationMap.put(view.getElement(), view); } break; } } for (Iterator children = view.getChildren().iterator(); children .hasNext();) { result.addAll(collectAllLinks((View) children.next(), domain2NotationMap)); } for (Iterator edges = view.getSourceEdges().iterator(); edges.hasNext();) { result.addAll(collectAllLinks((View) edges.next(), domain2NotationMap)); } return result; } /** * @generated */ private Collection<IAdaptable> createConnections( Collection<CompositionprogramLinkDescriptor> linkDescriptors, Map<EObject, View> domain2NotationMap) { LinkedList<IAdaptable> adapters = new LinkedList<IAdaptable>(); for (CompositionprogramLinkDescriptor nextLinkDescriptor : linkDescriptors) { EditPart sourceEditPart = getEditPart( nextLinkDescriptor.getSource(), domain2NotationMap); EditPart targetEditPart = getEditPart( nextLinkDescriptor.getDestination(), domain2NotationMap); if (sourceEditPart == null || targetEditPart == null) { continue; } CreateConnectionViewRequest.ConnectionViewDescriptor descriptor = new CreateConnectionViewRequest.ConnectionViewDescriptor( nextLinkDescriptor.getSemanticAdapter(), CompositionprogramVisualIDRegistry .getType(nextLinkDescriptor.getVisualID()), 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 getEditPart(EObject domainModelElement, Map<EObject, View> domain2NotationMap) { View view = (View) domain2NotationMap.get(domainModelElement); if (view != null) { return (EditPart) getHost().getViewer().getEditPartRegistry() .get(view); } return null; } /** * @generated */ private Diagram getDiagram() { return ((View) getHost().getModel()).getDiagram(); } }