| /******************************************************************************* |
| * Copyright (c) 2011, 2012, 2013 Red Hat, Inc. |
| * All rights reserved. |
| * This program is 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: |
| * Red Hat, Inc. - initial API and implementation |
| ******************************************************************************/ |
| package org.eclipse.bpmn2.modeler.core.features; |
| |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.Hashtable; |
| import java.util.List; |
| import java.util.Map.Entry; |
| |
| import org.eclipse.bpmn2.Activity; |
| import org.eclipse.bpmn2.Association; |
| import org.eclipse.bpmn2.BaseElement; |
| import org.eclipse.bpmn2.BoundaryEvent; |
| import org.eclipse.bpmn2.Bpmn2Factory; |
| import org.eclipse.bpmn2.Collaboration; |
| import org.eclipse.bpmn2.ConversationLink; |
| import org.eclipse.bpmn2.Definitions; |
| import org.eclipse.bpmn2.FlowElement; |
| import org.eclipse.bpmn2.FlowElementsContainer; |
| import org.eclipse.bpmn2.FlowNode; |
| import org.eclipse.bpmn2.InteractionNode; |
| import org.eclipse.bpmn2.Lane; |
| import org.eclipse.bpmn2.LaneSet; |
| import org.eclipse.bpmn2.MessageFlow; |
| import org.eclipse.bpmn2.Participant; |
| import org.eclipse.bpmn2.Process; |
| import org.eclipse.bpmn2.SequenceFlow; |
| import org.eclipse.bpmn2.di.BPMNDiagram; |
| import org.eclipse.bpmn2.di.BPMNEdge; |
| import org.eclipse.bpmn2.di.BPMNShape; |
| import org.eclipse.bpmn2.modeler.core.adapters.ExtendedPropertiesAdapter; |
| import org.eclipse.bpmn2.modeler.core.adapters.FeatureDescriptor; |
| import org.eclipse.bpmn2.modeler.core.di.DIUtils; |
| import org.eclipse.bpmn2.modeler.core.model.Bpmn2ModelerFactory; |
| import org.eclipse.bpmn2.modeler.core.utils.AnchorUtil; |
| import org.eclipse.bpmn2.modeler.core.utils.BusinessObjectUtil; |
| import org.eclipse.bpmn2.modeler.core.utils.FeatureSupport; |
| import org.eclipse.bpmn2.modeler.core.utils.GraphicsUtil; |
| import org.eclipse.bpmn2.modeler.core.utils.ModelUtil; |
| import org.eclipse.emf.common.util.TreeIterator; |
| import org.eclipse.emf.ecore.EClass; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.EStructuralFeature; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.util.EcoreUtil.Copier; |
| import org.eclipse.graphiti.datatypes.IDimension; |
| import org.eclipse.graphiti.datatypes.ILocation; |
| import org.eclipse.graphiti.features.IFeatureProvider; |
| import org.eclipse.graphiti.features.IUpdateFeature; |
| import org.eclipse.graphiti.features.context.IPasteContext; |
| import org.eclipse.graphiti.features.context.impl.AddConnectionContext; |
| import org.eclipse.graphiti.features.context.impl.AddContext; |
| import org.eclipse.graphiti.features.context.impl.AreaContext; |
| import org.eclipse.graphiti.features.context.impl.UpdateContext; |
| import org.eclipse.graphiti.mm.algorithms.styles.Point; |
| import org.eclipse.graphiti.mm.pictograms.Anchor; |
| import org.eclipse.graphiti.mm.pictograms.Connection; |
| import org.eclipse.graphiti.mm.pictograms.ContainerShape; |
| import org.eclipse.graphiti.mm.pictograms.Diagram; |
| import org.eclipse.graphiti.mm.pictograms.FreeFormConnection; |
| import org.eclipse.graphiti.mm.pictograms.PictogramElement; |
| import org.eclipse.graphiti.mm.pictograms.Shape; |
| import org.eclipse.graphiti.services.Graphiti; |
| import org.eclipse.graphiti.ui.editor.DiagramEditor; |
| import org.eclipse.graphiti.ui.features.AbstractPasteFeature; |
| |
| /** |
| * Default Graphiti {@code PasteFeature} class for Shapes. |
| * <p> |
| */ |
| public class DefaultPasteBPMNElementFeature extends AbstractPasteFeature { |
| |
| /** The EMF Resource. */ |
| protected Resource resource; |
| |
| /** The BPMN2 Definitions object - the root element of the document. */ |
| protected Definitions definitions; |
| |
| /** |
| * Maps the ID strings of the original BPMN2 elements to their |
| * corresponding newly constructed copies. |
| */ |
| protected Hashtable<String, String> idMap; |
| |
| /** The shape map. */ |
| protected HashMap<ContainerShape, ContainerShape> shapeMap; |
| |
| /** The connection map. */ |
| protected HashMap<Connection, Connection> connectionMap; |
| |
| /** The x reference. */ |
| protected int xReference; |
| |
| /** The y reference. */ |
| protected int yReference; |
| |
| /** The diagram. */ |
| protected Diagram diagram; |
| |
| /** |
| * Instantiates a new default {@code PasteFeature). |
| * |
| * @param fp the Feature Provider |
| */ |
| public DefaultPasteBPMNElementFeature(IFeatureProvider fp) { |
| super(fp); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.graphiti.features.IPasteFeature#canPaste(org.eclipse.graphiti.features.context.IPasteContext) |
| */ |
| @Override |
| public boolean canPaste(IPasteContext context) { |
| // target must be a FlowElementsContainer (Process, etc.) |
| ContainerShape targetContainerShape = getTargetContainerShape(context); |
| if (targetContainerShape==null) |
| return false; |
| BaseElement targetContainerObject = getContainerObject(targetContainerShape); |
| if (targetContainerObject==null) |
| return false; |
| |
| Object[] pasteObjects; |
| if (context.getProperty(GraphitiConstants.COPY_FROM_CONTEXT) != null) { |
| // Get objects to paste from the context. This can be used to test if |
| // objects can be pasted before they have been copied to the clipboard. |
| pasteObjects = context.getPictogramElements(); |
| } |
| else { |
| // can paste, if all objects on the clipboard are PictogramElements |
| pasteObjects = getFromClipboard(); |
| } |
| |
| if (pasteObjects == null || pasteObjects.length == 0) { |
| return false; |
| } |
| int count = 0; |
| for (Object object : pasteObjects) { |
| if (!(object instanceof PictogramElement)) { |
| continue; |
| } |
| PictogramElement pe = (PictogramElement) object; |
| BaseElement be = BusinessObjectUtil.getFirstBaseElement(pe); |
| if (!(be instanceof FlowElement) && !(be instanceof Lane) && !(be instanceof Participant)) { |
| continue; |
| } |
| // can't paste Boundary Events directly - these are "carried along" |
| // by the Activity to which they are attached. |
| if (be instanceof BoundaryEvent) { |
| continue; |
| } |
| // can't paste Label shapes |
| if (pe instanceof Shape && FeatureSupport.isLabelShape((Shape)pe)) { |
| continue; |
| } |
| // Participants can only be pasted into into a Collaboration |
| if (be instanceof Participant && !(targetContainerObject instanceof Collaboration)) { |
| continue; |
| } |
| ++count; |
| } |
| if (count==0) |
| return false; |
| |
| return true; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.graphiti.features.IPasteFeature#paste(org.eclipse.graphiti.features.context.IPasteContext) |
| */ |
| @Override |
| public void paste(IPasteContext context) { |
| ContainerShape targetContainerShape = getTargetContainerShape(context); |
| BaseElement targetContainerObject = getContainerObject(targetContainerShape); |
| |
| // save the Diagram and Resource needed for constructing the new objects |
| diagram = getFeatureProvider().getDiagramTypeProvider().getDiagram(); |
| resource = targetContainerObject.eResource(); |
| definitions = ModelUtil.getDefinitions(resource); |
| idMap = new Hashtable<String, String>(); |
| shapeMap = new HashMap<ContainerShape, ContainerShape>(); |
| connectionMap = new HashMap<Connection, Connection>(); |
| xReference = 0; |
| yReference = 0; |
| |
| int xMin = Integer.MAX_VALUE; |
| int yMin = Integer.MAX_VALUE; |
| Object[] fromClipboard = getFromClipboard(); |
| for (Object object : fromClipboard) { |
| if (object instanceof ContainerShape) { |
| ILocation loc = Graphiti.getLayoutService().getLocationRelativeToDiagram((ContainerShape) object); |
| if (loc.getX() < xMin) { |
| xMin = loc.getX(); |
| } |
| if (loc.getY() < yMin) { |
| yMin = loc.getY(); |
| } |
| } |
| } |
| if (xMin!=Integer.MAX_VALUE) { |
| xReference = xMin; |
| yReference = yMin; |
| } |
| |
| int x = context.getX(); |
| int y = context.getY(); |
| if (!(targetContainerShape instanceof Diagram)) { |
| ILocation loc = Graphiti.getLayoutService().getLocationRelativeToDiagram(targetContainerShape); |
| x -= loc.getX(); |
| y -= loc.getY(); |
| } |
| |
| // First create all shapes. This creates a lookup map of old to new |
| // ContainerShape objects. |
| for (Object object : fromClipboard) { |
| if (object instanceof ContainerShape) { |
| copyShape((ContainerShape) object, targetContainerShape, x, y); |
| } |
| } |
| |
| // Handle connections now that we know all shapes have been created |
| x = context.getX(); // Connection bendpoint coordinates are always |
| // relative to diagram |
| y = context.getY(); |
| for (Object object : fromClipboard) { |
| if (object instanceof Connection) { |
| copyConnection((Connection) object, targetContainerShape, x, y); |
| } |
| } |
| |
| // handle any connections that were not created because of missing source/target |
| for (Entry<Connection, Connection> entry : connectionMap.entrySet()) { |
| if (entry.getValue()==null) { |
| copyConnection(entry.getKey(), targetContainerShape, x, y); |
| } |
| } |
| PictogramElement newPes[] = new PictogramElement[shapeMap.size()]; |
| int i = 0; |
| for (Entry<ContainerShape, ContainerShape> entry : shapeMap.entrySet()) { |
| newPes[i++] = entry.getValue(); |
| } |
| |
| getDiagramEditor().setPictogramElementsForSelection(newPes); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.graphiti.ui.features.AbstractPasteFeature#getFromClipboard() |
| */ |
| protected Object[] getFromClipboard() { |
| List<Object> allObjects = new ArrayList<Object>(); |
| Object[] objects = super.getFromClipboard(); |
| for (Object object : objects) { |
| if (object instanceof EObject && ((EObject)object).eContainer()!=null) |
| allObjects.add(object); |
| } |
| |
| List<Object> filteredObjects = new ArrayList<Object>(); |
| for (Object object : allObjects) { |
| if (object instanceof EObject && ((EObject)object).eContainer()!=null) { |
| if (object instanceof ContainerShape) { |
| filteredObjects.add(object); |
| } |
| else if (object instanceof Connection) { |
| Connection c = (Connection)object; |
| if (c.getStart()!=null && c.getEnd()!=null) { |
| if (allObjects.contains(c.getStart().getParent()) && |
| allObjects.contains(c.getEnd().getParent())) { |
| filteredObjects.add(object); |
| } |
| } |
| } |
| } |
| } |
| |
| return filteredObjects.toArray(); |
| } |
| |
| public <T extends EObject> T copyEObject(T eObject) { |
| Copier copier = new Copier() { |
| |
| private static final long serialVersionUID = 1L; |
| |
| @Override |
| protected EObject createCopy(EObject eObject) { |
| EClass eClass = getTarget(eObject.eClass()); |
| if (eClass.getEPackage().getEFactoryInstance() == Bpmn2Factory.eINSTANCE) { |
| return Bpmn2ModelerFactory.createObject(resource, eClass); |
| } |
| return super.createCopy(eObject); |
| } |
| |
| }; |
| EObject result = copier.copy(eObject); |
| copier.copyReferences(); |
| |
| @SuppressWarnings("unchecked") |
| T t = (T) result; |
| |
| // don't set a name on the new object if old object didn't have one. |
| EStructuralFeature f = t.eClass().getEStructuralFeature("name"); //$NON-NLS-1$ |
| if (f!=null) { |
| String name = (String)eObject.eGet(f); |
| if (name==null || name.isEmpty()) |
| t.eSet(f, null); |
| } |
| |
| // add metadata to the ExtendedPropertiesAdapter for extension features |
| ExtendedPropertiesAdapter<T> oldAdapter = ExtendedPropertiesAdapter.adapt(eObject); |
| ExtendedPropertiesAdapter<T> newAdapter = ExtendedPropertiesAdapter.adapt(result); |
| for (EStructuralFeature oldFeature : oldAdapter.getExtensionFeatures()) { |
| FeatureDescriptor fd = newAdapter.getFeatureDescriptor(oldFeature); |
| fd.setProperty(ExtendedPropertiesAdapter.IS_EXTENSION_FEATURE, Boolean.TRUE); |
| } |
| |
| return t; |
| } |
| |
| private BaseElement createNewObject(BaseElement oldObject, BaseElement targetContainerObject) { |
| BaseElement newObject = null; |
| try { |
| Bpmn2ModelerFactory.lock(); |
| Bpmn2ModelerFactory.setEnableModelExtensions(false); |
| newObject = copyEObject(oldObject); |
| } |
| finally { |
| Bpmn2ModelerFactory.setEnableModelExtensions(true); |
| Bpmn2ModelerFactory.unlock(); |
| } |
| |
| if (targetContainerObject instanceof Participant) { |
| // need to create a Process for target container if it doesn't have one yet |
| Participant participant = (Participant) targetContainerObject; |
| if (participant.getProcessRef()==null) { |
| Process process = Bpmn2ModelerFactory.createObject(resource, Process.class); |
| participant.setProcessRef(process); |
| } |
| targetContainerObject = participant.getProcessRef(); |
| } |
| |
| // get rid of some of the objects created by EcoreUtil.copy() as these will be |
| // constructed here because we need to create the Graphiti shapes and DI elements |
| // along with these |
| if (newObject instanceof FlowElementsContainer) { |
| // we will create our own FlowElements, thank you! |
| ((FlowElementsContainer)newObject).getFlowElements().clear(); |
| } |
| |
| if (newObject instanceof Lane) { |
| // we will construct these ourselves |
| ((Lane) newObject).getFlowNodeRefs().clear(); |
| ((Lane) newObject).setChildLaneSet(null); |
| if (targetContainerObject instanceof FlowElementsContainer) { |
| FlowElementsContainer fc = (FlowElementsContainer)targetContainerObject; |
| if (fc.getLaneSets().size()!=0) { |
| fc.getLaneSets().get(0).getLanes().add((Lane)newObject); |
| } |
| else { |
| LaneSet ls = Bpmn2ModelerFactory.createObject(resource, LaneSet.class); |
| fc.getLaneSets().add(ls); |
| ls.getLanes().add((Lane)newObject); |
| } |
| } |
| else if (targetContainerObject instanceof Lane) { |
| Lane ln = (Lane)targetContainerObject; |
| if (ln.getChildLaneSet()==null) { |
| LaneSet ls = Bpmn2ModelerFactory.createObject(resource, LaneSet.class); |
| ln.setChildLaneSet(ls); |
| } |
| ln.getChildLaneSet().getLanes().add((Lane)newObject); |
| } |
| } |
| else if (newObject instanceof FlowElement) { |
| if (targetContainerObject instanceof Lane) { |
| Lane ln = (Lane)targetContainerObject; |
| targetContainerObject = getFlowElementsContainer(ln); |
| // newObject could be either a Shape (FlowNode) or a Connection; |
| // only add FlowNodes to the Lane's FlowNodeRefs list. |
| if (newObject instanceof FlowNode) |
| ln.getFlowNodeRefs().add((FlowNode)newObject); |
| } |
| if (targetContainerObject instanceof FlowElementsContainer) { |
| ((FlowElementsContainer)targetContainerObject).getFlowElements().add((FlowElement) newObject); |
| } |
| } |
| else if (newObject instanceof Participant) { |
| Participant participant = (Participant)newObject; |
| if (((Participant) newObject).getProcessRef()!=null) { |
| // need to create a new Process for this thing |
| Process process = Bpmn2ModelerFactory.createObject(resource, Process.class); |
| participant.setProcessRef(process); |
| } |
| if (targetContainerObject instanceof Collaboration) { |
| Collaboration collab = (Collaboration)targetContainerObject; |
| collab.getParticipants().add((Participant)newObject); |
| } |
| } |
| |
| // Ensure IDs are unique |
| setId(newObject); |
| |
| TreeIterator<EObject> iter = newObject.eAllContents(); |
| while (iter.hasNext()) { |
| EObject newChild = iter.next(); |
| setId(newChild); |
| } |
| |
| for (EReference ref : newObject.eClass().getEAllReferences()) { |
| if (!ref.isContainment()) { |
| Object oldValue = oldObject.eGet(ref); |
| // TODO: do we need this? |
| // this mess also duplicates "incoming" and "outgoing" (for SequenceFlows) |
| // which are already being handled in copyConnection()... |
| // if (oldValue instanceof EObjectEList) { |
| // EObjectEList oldList = (EObjectEList)oldObject.eGet(ref); |
| // EObjectEList newList = (EObjectEList)newObject.eGet(ref); |
| // for (Object oldRefObject : oldList) { |
| // if (oldRefObject instanceof EObject) { |
| // String oldId = getId((EObject)oldRefObject); |
| // if (oldId!=null) { |
| // String newId = idMap.get(oldId); |
| // EObject newRefObject = findObjectById(newId); |
| // newList.add(newRefObject); |
| // } |
| // } |
| // } |
| // } |
| // else |
| if (oldValue instanceof EObject){ |
| EObject oldRefObject = (EObject)oldValue; |
| String oldId = getId(oldRefObject); |
| if (oldId!=null) { |
| String newId = idMap.get(oldId); |
| if (newId!=null) { |
| EObject newRefObject = findObjectById(newId); |
| newObject.eSet(ref, newRefObject); |
| } |
| else if (newObject.eGet(ref) != null){ |
| EObject newRefObject = (EObject) newObject.eGet(ref); |
| newId = getId(newRefObject); |
| if (newId!=null) |
| idMap.put(oldId, newId); |
| } |
| } |
| } |
| } |
| } |
| return newObject; |
| } |
| |
| private String getId(EObject newObject) { |
| EStructuralFeature feature = newObject.eClass().getEStructuralFeature("id"); //$NON-NLS-1$ |
| if (feature != null) { |
| return (String) newObject.eGet(feature); |
| } |
| return null; |
| } |
| |
| private String setId(EObject newObject) { |
| String newId = null; |
| String oldId = null; |
| EStructuralFeature feature = newObject.eClass().getEStructuralFeature("id"); //$NON-NLS-1$ |
| if (feature != null) { |
| oldId = (String) newObject.eGet(feature); |
| if (idMap.contains(oldId)) { |
| newId = idMap.get(oldId); |
| newObject.eSet(feature, newId); |
| } |
| else { |
| newObject.eUnset(feature); |
| newId = ModelUtil.setID(newObject); |
| idMap.put(oldId, newId); |
| } |
| } |
| return oldId; |
| } |
| |
| private boolean wasCopied(EObject object) { |
| String id = getId(object); |
| if (id!=null) { |
| return idMap.containsValue(id); |
| } |
| return false; |
| } |
| |
| private EObject findObjectById(String id) { |
| TreeIterator<EObject> iter = definitions.eAllContents(); |
| while (iter.hasNext()) { |
| EObject o = iter.next(); |
| EStructuralFeature feature = o.eClass().getEStructuralFeature("id"); //$NON-NLS-1$ |
| if (feature != null) { |
| String thisId = (String) o.eGet(feature); |
| if (thisId != null && !thisId.isEmpty() && thisId.equals(id)) |
| return o; |
| } |
| } |
| return null; |
| } |
| |
| private ContainerShape findShape(EObject object) { |
| List<PictogramElement> pes = Graphiti.getLinkService().getPictogramElements(diagram, object); |
| for (PictogramElement pe : pes) { |
| if (pe instanceof ContainerShape) |
| return (ContainerShape) pe; |
| } |
| return null; |
| } |
| |
| private Connection findConnection(EObject object) { |
| List<PictogramElement> pes = Graphiti.getLinkService().getPictogramElements(diagram, object); |
| for (PictogramElement pe : pes) { |
| if (pe instanceof Connection) |
| return (Connection) pe; |
| } |
| return null; |
| } |
| |
| private BaseElement copyShape(ContainerShape oldShape, ContainerShape targetContainerShape, int x, int y) { |
| if (shapeMap.get(oldShape)!=null) |
| return null; |
| |
| BaseElement targetContainerObject = getContainerObject(targetContainerShape); |
| BaseElement oldObject = BusinessObjectUtil.getFirstBaseElement(oldShape); |
| BaseElement newObject = createNewObject(oldObject, targetContainerObject); |
| |
| AddContext ac = new AddContext(new AreaContext(), newObject); |
| ILocation loc = Graphiti.getLayoutService().getLocationRelativeToDiagram(oldShape); |
| IDimension size = GraphicsUtil.calculateSize(oldShape); |
| // The default Add BPMN Shape feature will position the new shape so its |
| // center is at the target location; for copy/paste we want to use the |
| // top-left corner instead so that copied connection bendpoints (if any) |
| // line up properly. |
| int deltaX = 0; |
| int deltaY = 0; |
| if (oldObject instanceof FlowNode) { |
| deltaX = loc.getX() - xReference + size.getWidth() / 2; |
| deltaY = loc.getY() - yReference + size.getHeight() / 2; |
| } |
| ac.setLocation(x + deltaX, y + deltaY); |
| ac.setSize(size.getWidth(), size.getHeight()); |
| ac.setTargetContainer(targetContainerShape); |
| |
| BPMNShape oldBpmnShape = null; |
| if (oldObject instanceof BaseElement) { |
| BPMNDiagram bpmnDiagram = DIUtils.findBPMNDiagram(oldShape); |
| oldBpmnShape = DIUtils.findBPMNShape(bpmnDiagram, (BaseElement)oldObject); |
| ac.putProperty(GraphitiConstants.COPIED_BPMN_DI_ELEMENT, oldBpmnShape); |
| } |
| ac.putProperty(GraphitiConstants.COPIED_BPMN_OBJECT, oldObject); |
| |
| |
| ContainerShape newShape = (ContainerShape) getFeatureProvider().addIfPossible(ac); |
| |
| shapeMap.put(oldShape, newShape); |
| |
| if (oldObject instanceof Participant) { |
| // copy the contained Process elements |
| oldObject = ((Participant)oldObject).getProcessRef(); |
| } |
| |
| // create shapes and connections for children if this is a FlowElementsContainer |
| if (oldObject instanceof FlowElementsContainer) { |
| List<ContainerShape> childShapes = new ArrayList<ContainerShape>(); |
| List<Connection> childConnections = new ArrayList<Connection>(); |
| TreeIterator<EObject> iter = oldObject.eAllContents(); |
| while (iter.hasNext()) { |
| // look up the old child object that corresponds to the new child object |
| EObject oldChildObject = iter.next(); |
| if (oldChildObject instanceof BoundaryEvent) { |
| // Defer Boundary Event creation until we're sure that the |
| // new attachedToRef task is actually created. |
| continue; |
| } |
| if (wasCopied(oldChildObject)) { |
| // stop infinite recursion: this would happen if a FlowElementsContainer |
| //was copied into itself. |
| continue; |
| } |
| |
| // if the old child has a Graphiti ContainerShape, duplicate it. |
| ContainerShape oldChildShape = findShape(oldChildObject); |
| if (oldChildShape != null) { |
| childShapes.add(oldChildShape); |
| } |
| Connection oldChildConnection = findConnection(oldChildObject); |
| if (oldChildConnection != null) { |
| childConnections.add(oldChildConnection); |
| } |
| } |
| |
| for (ContainerShape oldChildShape : childShapes) { |
| copyShape(oldChildShape, newShape, 0, 0); |
| } |
| |
| for (Connection oldChildConnection : childConnections) { |
| copyConnection(oldChildConnection, newShape, x, y); |
| } |
| } |
| else if (oldObject instanceof Lane) { |
| List<PictogramElement> shapes = new ArrayList<PictogramElement>(); |
| Lane oldLane = (Lane)oldObject; |
| if (oldLane.getChildLaneSet()!=null) { |
| for (Lane oldChildLaneObject : oldLane.getChildLaneSet().getLanes()) { |
| ContainerShape oldChildLaneShape = findShape(oldChildLaneObject); |
| if (oldChildLaneShape != null) { |
| copyShape(oldChildLaneShape, newShape, 0, 0); |
| } |
| } |
| } |
| for (FlowNode oldChildObject : oldLane.getFlowNodeRefs()) { |
| ContainerShape oldChildShape = findShape(oldChildObject); |
| if (oldChildShape != null) { |
| copyShape(oldChildShape, newShape, 0, 0); |
| shapes.add(oldChildShape); |
| } |
| } |
| List<Connection> connections = DefaultCopyBPMNElementFeature.findAllConnections(shapes); |
| for (Connection oldChildConnection : connections) { |
| copyConnection(oldChildConnection, newShape, x, y); |
| } |
| } |
| |
| // also copy the BPMNShape properties |
| if (oldBpmnShape!=null) { |
| BPMNShape newBpmnShape = DIUtils.findBPMNShape((BaseElement)newObject); |
| newBpmnShape.setIsExpanded(oldBpmnShape.isIsExpanded()); |
| newBpmnShape.setIsHorizontal(oldBpmnShape.isIsHorizontal()); |
| newBpmnShape.setIsMarkerVisible(oldBpmnShape.isIsMarkerVisible()); |
| newBpmnShape.setIsMessageVisible(oldBpmnShape.isIsMessageVisible()); |
| newBpmnShape.setParticipantBandKind(oldBpmnShape.getParticipantBandKind()); |
| } |
| |
| UpdateContext uc = new UpdateContext(newShape); |
| IUpdateFeature uf = getFeatureProvider().getUpdateFeature(uc); |
| // force an update to cause the newly created ContainerShape to be rendered properly |
| uc.putProperty(GraphitiConstants.FORCE_UPDATE_ALL, Boolean.TRUE); |
| uf.update(uc); |
| |
| if (newObject instanceof Activity) { |
| // copy the Activity's Boundary Events if it has any |
| TreeIterator<EObject> i = definitions.eAllContents(); |
| while (i.hasNext()) { |
| EObject o = i.next(); |
| if (o instanceof BoundaryEvent) { |
| BoundaryEvent oldBeObject = (BoundaryEvent)o; |
| if (oldBeObject.getAttachedToRef() == oldObject) { |
| // here's one... |
| ContainerShape oldBeShape = findShape(oldBeObject); |
| copyShape(oldBeShape, targetContainerShape, x, y); |
| } |
| } |
| } |
| } |
| |
| return newObject; |
| } |
| |
| private BaseElement copyConnection(Connection oldConnection, ContainerShape targetContainerShape, int x, int y) { |
| if (connectionMap.get(oldConnection)!=null) |
| return null; |
| |
| BaseElement targetContainerObject = getContainerObject(targetContainerShape); |
| BaseElement oldObject = BusinessObjectUtil.getFirstBaseElement(oldConnection); |
| BaseElement newObject = createNewObject(oldObject, targetContainerObject); |
| |
| Anchor oldStart = oldConnection.getStart(); |
| Anchor oldEnd = oldConnection.getEnd(); |
| ContainerShape newSource = shapeMap.get(oldStart.getParent()); |
| ContainerShape newTarget = shapeMap.get(oldEnd.getParent()); |
| if (newSource==null || newTarget==null) { |
| // source or target does not exist yet - handle this connection later |
| connectionMap.put(oldConnection, null); |
| return null; |
| } |
| |
| Anchor newStart; |
| Anchor newEnd; |
| ILocation loc = Graphiti.getLayoutService().getLocationRelativeToDiagram(oldStart); |
| newStart = AnchorUtil.createAnchor(newSource, loc.getX(), loc.getY()); |
| |
| loc = Graphiti.getLayoutService().getLocationRelativeToDiagram(oldEnd); |
| newEnd = AnchorUtil.createAnchor(newTarget, loc.getX(), loc.getY()); |
| |
| BaseElement newSourceObject = BusinessObjectUtil.getFirstBaseElement(newSource); |
| BaseElement newTargetObject = BusinessObjectUtil.getFirstBaseElement(newTarget); |
| if (newObject instanceof SequenceFlow) { |
| ((SequenceFlow) newObject).setSourceRef((FlowNode) newSourceObject); |
| ((SequenceFlow) newObject).setTargetRef((FlowNode) newTargetObject); |
| } |
| else if (newObject instanceof Association) { |
| ((Association) newObject).setSourceRef((FlowNode) newSourceObject); |
| ((Association) newObject).setTargetRef((FlowNode) newTargetObject); |
| } |
| else if (newObject instanceof MessageFlow) { |
| ((MessageFlow) newObject).setSourceRef((InteractionNode) newSourceObject); |
| ((MessageFlow) newObject).setTargetRef((InteractionNode) newTargetObject); |
| } |
| else if (newObject instanceof ConversationLink) { |
| ((ConversationLink) newObject).setSourceRef((InteractionNode) newSourceObject); |
| ((ConversationLink) newObject).setTargetRef((InteractionNode) newTargetObject); |
| } |
| AddConnectionContext acc = new AddConnectionContext(newStart, newEnd); |
| acc.setNewObject(newObject); |
| |
| Connection newConnection = (Connection) getFeatureProvider().addIfPossible(acc); |
| connectionMap.put(oldConnection, newConnection); |
| |
| if (oldConnection instanceof FreeFormConnection && newConnection instanceof FreeFormConnection) { |
| for (Point p : ((FreeFormConnection) oldConnection).getBendpoints()) { |
| int deltaX = p.getX() - xReference; |
| int deltaY = p.getY() - yReference; |
| Point newPoint = GraphicsUtil.createPoint(x + deltaX, y + deltaY); |
| ((FreeFormConnection) newConnection).getBendpoints().add(newPoint); |
| } |
| } |
| |
| // also copy the BPMNEdge properties |
| if (oldObject instanceof BaseElement) { |
| BPMNDiagram bpmnDiagram = DIUtils.findBPMNDiagram(oldConnection); |
| BPMNEdge oldBpmnEdge = DIUtils.findBPMNEdge(bpmnDiagram, (BaseElement)oldObject); |
| if (oldBpmnEdge!=null) { |
| bpmnDiagram = DIUtils.findBPMNDiagram(newConnection); |
| BPMNEdge newBpmnEdge = DIUtils.findBPMNEdge(bpmnDiagram, (BaseElement)newObject); |
| newBpmnEdge.setMessageVisibleKind(oldBpmnEdge.getMessageVisibleKind()); |
| } |
| } |
| |
| FeatureSupport.updateConnection(getFeatureProvider(), newConnection); |
| |
| return newObject; |
| } |
| |
| private ContainerShape getTargetContainerShape(IPasteContext context) { |
| Diagram diagram = getFeatureProvider().getDiagramTypeProvider().getDiagram(); |
| |
| Point p = GraphicsUtil.createPoint(context.getX(), context.getY()); |
| Shape s = GraphicsUtil.findShapeAt(diagram, p, new GraphicsUtil.IShapeFilter() { |
| @Override |
| public boolean matches(Shape shape) { |
| if (shape instanceof ContainerShape) { |
| BaseElement be = getContainerObject((ContainerShape) shape); |
| return be instanceof FlowElementsContainer || be instanceof Participant; |
| } |
| return false; |
| } |
| }); |
| if (s!=null) |
| return (ContainerShape) s; |
| return diagram; |
| } |
| |
| private BaseElement getContainerObject(ContainerShape targetContainerShape) { |
| EObject bo = BusinessObjectUtil.getBusinessObjectForPictogramElement(targetContainerShape); |
| if (bo instanceof BPMNDiagram) { |
| bo = ((BPMNDiagram) bo).getPlane().getBpmnElement(); |
| } |
| if (bo instanceof Participant) { |
| if (!FeatureSupport.isChoreographyParticipantBand(targetContainerShape)) |
| return (Participant) bo; |
| bo = ((Participant) bo).getProcessRef(); |
| } |
| if (bo instanceof FlowElementsContainer || bo instanceof Lane || bo instanceof Collaboration) |
| return (BaseElement) bo; |
| return null; |
| } |
| |
| private FlowElementsContainer getFlowElementsContainer(Lane lane) { |
| EObject container = lane.eContainer(); |
| while (!(container instanceof FlowElementsContainer) && container!=null) |
| container = container.eContainer(); |
| return (FlowElementsContainer)container; |
| } |
| |
| protected DiagramEditor getDiagramEditor() { |
| return (DiagramEditor)getFeatureProvider().getDiagramTypeProvider().getDiagramBehavior().getDiagramContainer(); |
| } |
| } |
