plugins/org.eclipse.bpmn2.modeler.core/src/org/eclipse/bpmn2/modeler/core/features/AbstractBpmn2AddFeature.java - bpmn2-modeler/org.eclipse.bpmn2-modeler - Git at Google

 /*******************************************************************************
  * Copyright (c) 2011, 2012 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
  *
  * @author Ivar Meikas
  ******************************************************************************/
 package org.eclipse.bpmn2.modeler.core.features;

 import org.eclipse.bpmn2.BaseElement;
 import org.eclipse.bpmn2.EndEvent;
 import org.eclipse.bpmn2.Lane;
 import org.eclipse.bpmn2.Participant;
 import org.eclipse.bpmn2.StartEvent;
 import org.eclipse.bpmn2.di.BPMNDiagram;
 import org.eclipse.bpmn2.di.BPMNEdge;
 import org.eclipse.bpmn2.di.BPMNShape;
 import org.eclipse.bpmn2.modeler.core.Activator;
 import org.eclipse.bpmn2.modeler.core.di.DIImport;
 import org.eclipse.bpmn2.modeler.core.di.DIUtils;
 import org.eclipse.bpmn2.modeler.core.features.flow.AbstractCreateFlowFeature;
 import org.eclipse.bpmn2.modeler.core.preferences.Bpmn2Preferences;
 import org.eclipse.bpmn2.modeler.core.preferences.ShapeStyle;
 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.ShapeDecoratorUtil;
 import org.eclipse.dd.dc.Bounds;
 import org.eclipse.graphiti.IExecutionInfo;
 import org.eclipse.graphiti.datatypes.ILocation;
 import org.eclipse.graphiti.features.IAddFeature;
 import org.eclipse.graphiti.features.ICreateConnectionFeature;
 import org.eclipse.graphiti.features.IFeatureProvider;
 import org.eclipse.graphiti.features.IReason;
 import org.eclipse.graphiti.features.IReconnectionFeature;
 import org.eclipse.graphiti.features.context.IAddConnectionContext;
 import org.eclipse.graphiti.features.context.IAddContext;
 import org.eclipse.graphiti.features.context.ITargetContext;
 import org.eclipse.graphiti.features.context.impl.AddContext;
 import org.eclipse.graphiti.features.context.impl.CreateConnectionContext;
 import org.eclipse.graphiti.features.context.impl.LayoutContext;
 import org.eclipse.graphiti.features.context.impl.ReconnectionContext;
 import org.eclipse.graphiti.features.context.impl.UpdateContext;
 import org.eclipse.graphiti.features.impl.AbstractAddPictogramElementFeature;
 import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
 import org.eclipse.graphiti.mm.algorithms.RoundedRectangle;
 import org.eclipse.graphiti.mm.pictograms.Anchor;
 import org.eclipse.graphiti.mm.pictograms.AnchorContainer;
 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.FixPointAnchor;
 import org.eclipse.graphiti.mm.pictograms.PictogramElement;
 import org.eclipse.graphiti.mm.pictograms.Shape;
 import org.eclipse.graphiti.services.Graphiti;
 import org.eclipse.graphiti.services.IGaService;
 import org.eclipse.graphiti.services.ILayoutService;
 import org.eclipse.graphiti.services.IPeService;
 import org.eclipse.graphiti.ui.editor.DiagramEditor;

 /**
  * This is the Graphiti {@code AddFeature} base class for all BPMN2 model elements which
  * are associated with BPMN DI elements.
  * <p>
  * This class adds support for managing BPMN DI elements, i.e. BPMNShape and
  * BPMNEdge.
  * <p>
  * Note that the BPMNLabel element is not yet supported, but will be added in a
  * future release. For now, graphical shapes with labels are supported
  * indirectly outside the scope of BPMN DI.
  *
  * @param <T> the generic type, a subclass of {@link BaseElement}
  */
 public abstract class AbstractBpmn2AddFeature<T extends BaseElement>
 	extends AbstractAddPictogramElementFeature {

 	/** The ga service. */
 	protected final static IGaService gaService = Graphiti.getGaService();

 	/** The pe service. */
 	protected final static IPeService peService = Graphiti.getPeService();

 	/** The preferences. */
 	protected Bpmn2Preferences preferences;

 	/**
 	 * Instantiates a new AddFeature.
 	 *
 	 * @param fp the Feature Provider instance
 	 */
 	public AbstractBpmn2AddFeature(IFeatureProvider fp) {
 		super(fp);
 		preferences = Bpmn2Preferences.getInstance(getDiagram());
 	}

 	public abstract IAddFeature getAddLabelFeature(IFeatureProvider fp);

 	/**
 	 * Find the BPMNShape that references the given {@code BaseElement}.
 	 *
 	 * @param elem the BaseElement
 	 * @return the BPMNShape object if found or null if it has not been created yet.
 	 */
 	protected BPMNShape findDIShape(BaseElement elem) {
 		try {
 			return DIUtils.findBPMNShape(elem);
 		} catch (Exception e) {
 			Activator.logError(e);
 		}
 		return null;
 	}

 	/**
 	 * Creates a BPMNShape if it does not already exist, and then links it to
 	 * the given {@code BaseElement}.
 	 *
 	 * @param shape the Container Shape
 	 * @param elem the BaseElement
 	 * @param applyDefaults if true, apply User Preference defaults for certain
 	 *            BPMN DI attributes, e.g. isHorizontal, isExpanded, etc.
 	 * @return the BPMNShape
 	 */
 	protected BPMNShape createDIShape(Shape shape, BaseElement elem, boolean applyDefaults) {
 		BPMNShape bpmnShape = null;
 		Diagram diagram = Graphiti.getPeService().getDiagramForShape(shape);
 		if (diagram!=null) {
 			BPMNDiagram bpmnDiagram = (BPMNDiagram) BusinessObjectUtil.getBusinessObjectForPictogramElement(diagram);
 			bpmnShape = DIUtils.findBPMNShape(bpmnDiagram, elem);
 		}
 		else
 			bpmnShape = findDIShape(elem);
 		bpmnShape = DIUtils.createDIShape(shape, elem, bpmnShape, getFeatureProvider());
 		if (applyDefaults && bpmnShape!=null)
 			preferences.applyBPMNDIDefaults(bpmnShape, null);
 		return bpmnShape;
 	}

 	/**
 	 * Creates a BPMNEdge if it does not already exist, and then links it to
 	 * the given {@code BaseElement}.
 	 *
 	 * @param connection the connection
 	 * @param elem the BaseElement
 	 * @return the BPMNEdge
 	 */
 	protected BPMNEdge createDIEdge(Connection connection, BaseElement elem) {
 		BPMNDiagram bpmnDiagram = DIUtils.findBPMNDiagram(connection);
 		BPMNEdge edge = DIUtils.findBPMNEdge(bpmnDiagram, elem);
 		return DIUtils.createDIEdge(connection, elem, edge, getFeatureProvider());
 	}

 	/**
 	 * Adjust the location of a newly constructed shape so that its center is at
 	 * the mouse cursor position.
 	 *
 	 * @param context the AddContext
 	 * @param width the new shape's width
 	 * @param height the new shape's height
 	 */
 	protected void adjustLocation(IAddContext context, int width, int height) {
 		if (DIImport.isImporting(context)) {
 			return;
 		}

 		int x = context.getX();
 		int y = context.getY();
 		((AddContext)context).setWidth(width);
 		((AddContext)context).setHeight(height);

 		y -= height/2;
 		x -= width / 2;
 		((AddContext)context).setY(y);
 		((AddContext)context).setX(x);
 	}

 	/**
 	 * Split a connection. This is used when a shape is dropped onto a
 	 * connection; the target of the original connection is attached to the new
 	 * shape, and a new connection is created that connects the new shape to the
 	 * old connection's target.
 	 *
 	 * @param context the AddContext for the new shape. This will have the
 	 *            target connection which needs to be split
 	 * @param containerShape the new container shape that was dropped onto the
 	 *            connection
 	 */
 	protected void splitConnection(IAddContext context, ContainerShape containerShape) {
 		if (context.getProperty(GraphitiConstants.IMPORT_PROPERTY) != null) {
 			return;
 		}

 		Object newObject = getBusinessObject(context);
 		Connection connection = context.getTargetConnection();
 		if (connection!=null) {
 			// determine how to split the line depending on where the new object was dropped:
 			// the longer segment will remain the original connection, and a new connection
 			// will be created for the shorter segment
 			ILayoutService layoutService = Graphiti.getLayoutService();
 			Anchor a0 = connection.getStart();
 			Anchor a1 = connection.getEnd();
 			double x0 = layoutService.getLocationRelativeToDiagram(a0).getX();
 			double y0 = layoutService.getLocationRelativeToDiagram(a0).getY();
 			double x1 = layoutService.getLocationRelativeToDiagram(a1).getX();
 			double y1 = layoutService.getLocationRelativeToDiagram(a1).getY();
 			double dx = x0 - context.getX();
 			double dy = y0 - context.getY();
 			double len0 = Math.sqrt(dx*dx + dy*dy);
 			dx = context.getX() - x1;
 			dy = context.getY() - y1;
 			double len1 = Math.sqrt(dx*dx + dy*dy);

 			AnchorContainer oldSourceContainer = connection.getStart().getParent();
 			AnchorContainer oldTargetContainer = connection.getEnd().getParent();
 			BaseElement baseElement = BusinessObjectUtil.getFirstElementOfType(connection, BaseElement.class);
 			ILocation targetLocation = layoutService.getLocationRelativeToDiagram(containerShape);

 			ReconnectionContext rc;
 			FixPointAnchor anchor;

 			if (newObject instanceof StartEvent || (len0 < len1 && !(newObject instanceof EndEvent))) {
 				anchor = AnchorUtil.createAnchor(containerShape, GraphicsUtil.getShapeCenter(oldTargetContainer));
 				rc = new ReconnectionContext(connection, connection.getStart(), anchor, targetLocation);
 				rc.setReconnectType(ReconnectionContext.RECONNECT_SOURCE);
 				rc.setTargetPictogramElement(containerShape);
 			}
 			else {
 				anchor = AnchorUtil.createAnchor(containerShape, GraphicsUtil.getShapeCenter(containerShape));
 				rc = new ReconnectionContext(connection, connection.getEnd(), anchor, targetLocation);
 				rc.setReconnectType(ReconnectionContext.RECONNECT_TARGET);
 				rc.setTargetPictogramElement(containerShape);
 			}
 			IReconnectionFeature rf = getFeatureProvider().getReconnectionFeature(rc);
 			rf.reconnect(rc);

 			if (!(newObject instanceof EndEvent) && !(newObject instanceof StartEvent)) {
 				// connection = get create feature, create connection
 				CreateConnectionContext ccc = new CreateConnectionContext();
 				if (len0 < len1) {
 					ccc.setSourcePictogramElement(oldSourceContainer);
 					ccc.setTargetPictogramElement(containerShape);
 					anchor = AnchorUtil.createAnchor(oldSourceContainer, GraphicsUtil.getShapeCenter(containerShape));
 					ccc.setSourceAnchor(anchor);
 					anchor = AnchorUtil.createAnchor(containerShape, GraphicsUtil.getShapeCenter(oldTargetContainer));
 					ccc.setTargetAnchor(anchor);
 				}
 				else {
 					ccc.setSourcePictogramElement(containerShape);
 					ccc.setTargetPictogramElement(oldTargetContainer);
 					anchor = AnchorUtil.createAnchor(containerShape, GraphicsUtil.getShapeCenter(oldTargetContainer));
 					ccc.setSourceAnchor(anchor);
 					anchor = AnchorUtil.createAnchor(oldTargetContainer, GraphicsUtil.getShapeCenter(containerShape));
 					ccc.setTargetAnchor(anchor);
 				}

 				Connection newConnection = null;
 				ICreateConnectionFeature ccf = AbstractCreateFlowFeature.getCreateFeature(getFeatureProvider(), ccc, baseElement);
 				if (ccf!=null)
 					newConnection = ccf.create(ccc);
 				DIUtils.updateDIEdge(newConnection);
 			}
 			DIUtils.updateDIEdge(connection);
 		}
 	}

 	/**
 	 * Gets the height of a new shape based on User Preferences. If the shape is a copy of
 	 * another shape, the height of the copied shape is used.
 	 *
 	 * @param context the AddContext for the new shape
 	 * @return the height
 	 */
 	protected int getHeight(IAddContext context) {
 		Object copiedBpmnShape = context.getProperty(GraphitiConstants.COPIED_BPMN_DI_ELEMENT);
 		if (copiedBpmnShape instanceof BPMNShape) {
 			Bounds b = ((BPMNShape)copiedBpmnShape).getBounds();
 			if (b!=null)
 //				if (isHorizontal(context))
 //					return (int) b.getWidth();
 				return (int) b.getHeight();
 		}
 		if (context.getHeight() > 0)
 			return context.getHeight();
 		if (context.getProperty(GraphitiConstants.IMPORT_PROPERTY) == null) {
 			if (isHorizontal(context)) {
 				if (context.getWidth() > 0)
 					return context.getWidth();
 				return getWidth();
 			}
 		}
 		return getHeight();
 	}

 	/**
 	 * Gets the width of a new shape based on User Preferences. If the shape is a copy of
 	 * another shape, the width of the copied shape is used.
 	 *
 	 * @param context the AddContext for the new shape
 	 * @return the width
 	 */
 	protected int getWidth(IAddContext context) {
 		Object copiedBpmnShape = context.getProperty(GraphitiConstants.COPIED_BPMN_DI_ELEMENT);
 		if (copiedBpmnShape instanceof BPMNShape) {
 			Bounds b = ((BPMNShape)copiedBpmnShape).getBounds();
 			if (b!=null) {
 //				if (isHorizontal(context))
 //					return (int) b.getHeight();
 				return (int) b.getWidth();
 			}
 		}
 		if (context.getWidth() > 0)
 			return context.getWidth();
 		if (context.getProperty(GraphitiConstants.IMPORT_PROPERTY) == null) {
 			if (isHorizontal(context)) {
 				if (context.getHeight() > 0)
 					return context.getHeight();
 				return getHeight();
 			}
 		}
 		return getWidth();
 	}

 	/**
 	 * Gets the height.
 	 *
 	 * @return the height
 	 */
 	protected int getHeight() {
 		ShapeStyle ss = preferences.getShapeStyle(getBusinessObjectType());
 		return ss.getDefaultHeight();
 	}

 	/**
 	 * Gets the width.
 	 *
 	 * @return the width
 	 */
 	protected int getWidth() {
 		ShapeStyle ss = preferences.getShapeStyle(getBusinessObjectType());
 		return ss.getDefaultWidth();
 	}

 	/**
 	 * Checks User Preferences if horizontal layout is preferred.
 	 *
 	 * @param context the context
 	 * @return true, if is horizontal
 	 */
 	protected boolean isHorizontal(ITargetContext context) {
 		// isHorizontal only applies to Lanes and Pools
 		if (context instanceof IAddContext) {
 			Object newObject = ((IAddContext)context).getNewObject();
 			if (!(newObject instanceof Lane) && !(newObject instanceof Participant))
 				return false;
 		}
 		if (context.getProperty(GraphitiConstants.IMPORT_PROPERTY) == null) {
 			// not importing - set isHorizontal to be the same as copied element or parent
 			Object copiedBpmnShape = context.getProperty(GraphitiConstants.COPIED_BPMN_DI_ELEMENT);
 			if (copiedBpmnShape instanceof BPMNShape) {
 				return ((BPMNShape)copiedBpmnShape).isIsHorizontal();
 			}

 			if (FeatureSupport.isTargetParticipant(context)) {
 				Participant targetParticipant = FeatureSupport.getTargetParticipant(context);
 				BPMNShape participantShape = findDIShape(targetParticipant);
 				if (participantShape!=null)
 					return participantShape.isIsHorizontal();
 			}
 			else if (FeatureSupport.isTargetLane(context)) {
 				Lane targetLane = FeatureSupport.getTargetLane(context);
 				BPMNShape laneShape = findDIShape(targetLane);
 				if (laneShape!=null)
 					return laneShape.isIsHorizontal();
 			}
 		}
 		return FeatureSupport.isHorizontal(context);
 	}

 	public abstract Class<? extends BaseElement> getBusinessObjectType();

 	public T getBusinessObject(IAddContext context) {
 		Object businessObject = context.getProperty(GraphitiConstants.BUSINESS_OBJECT);
 		if (businessObject instanceof BaseElement)
 			return (T)businessObject;
 		return (T)context.getNewObject();
 	}

 	public void putBusinessObject(IAddContext context, T businessObject) {
 		context.putProperty(GraphitiConstants.BUSINESS_OBJECT, businessObject);
 	}

 	public void postExecute(IExecutionInfo executionInfo) {
 	}

 	/**
 	 * Helper function to return the GraphicsAlgorithm for a ContainerShape created by
 	 * one of the BPMN2 Modeler's Add features. This can be used by subclasses to decorate
 	 * the figure on the diagram.
 	 *
 	 * @param containerShape the container shape
 	 * @return the graphics algorithm
 	 */
 	protected static GraphicsAlgorithmContainer getGraphicsAlgorithm(ContainerShape containerShape) {
 		if (containerShape.getGraphicsAlgorithm() instanceof RoundedRectangle)
 			return containerShape.getGraphicsAlgorithm();
 		if (containerShape.getChildren().size()>0) {
 			Shape shape = containerShape.getChildren().get(0);
 			return shape.getGraphicsAlgorithm();
 		}
 		return null;
 	}

 	/**
 	 * Decorate connection. This is a placeholder for the hook function invoked
 	 * when the connection is added to the diagram. Implementations can override
 	 * this to change the appearance of the connection.
 	 *
 	 * @param context the Add Context
 	 * @param connection the connection being added
 	 * @param businessObject the business object, a {@code BaseElement} subclass.
 	 */
 	protected void decorateConnection(IAddConnectionContext context, Connection connection, T businessObject) {
 	}

 	/**
 	 * Decorate shape. This is a placeholder for the hook function invoked when
 	 * the shape is added to the diagram. Implementations can override this to
 	 * change the appearance of the shape.
 	 *
 	 * @param context the Add Context
 	 * @param containerShape the container shape being added
 	 * @param businessObject the business object, a {@code BaseElement} subclass.
 	 */
 	protected void decorateShape(IAddContext context, ContainerShape containerShape, T businessObject) {
 		ShapeDecoratorUtil.createValidationDecorator(containerShape);
 	}

 	/**
 	 * Update the given PictogramElement. A Graphiti UpdateContext is constructed by copying
 	 * the properties from the given AddContext.
 	 *
 	 * @param addContext the Graphiti AddContext that was used to add the PE to the Diagram
 	 * @param pe the PictogramElement
 	 * @return a reason code indicating whether or not an update is needed.
 	 */
 	public IReason updatePictogramElement(IAddContext addContext, PictogramElement pe) {
 		UpdateContext updateContext = new UpdateContext(pe);
 		for (Object key : addContext.getPropertyKeys()) {
 			Object value = addContext.getProperty(key);
 			updateContext.putProperty(key, value);
 		}
 		return getFeatureProvider().updateIfPossible(updateContext);
 	}

 	/**
 	 * Layout the given PictogramElement. A Graphiti LayoutContext is constructed by copying
 	 * the properties from the given AddContext.
 	 *
 	 * @param addContext the Graphiti AddContext that was used to add the PE to the Diagram
 	 * @param pe the PictogramElement
 	 * @return a reason code indicating whether or not a layout is needed.
 	 */
 	public IReason layoutPictogramElement(IAddContext addContext, PictogramElement pe) {
 		LayoutContext layoutContext = new LayoutContext(pe);
 		for (Object key : addContext.getPropertyKeys()) {
 			Object value = addContext.getProperty(key);
 			layoutContext.putProperty(key, value);
 		}
 		return getFeatureProvider().layoutIfPossible(layoutContext);
 	}

 	protected DiagramEditor getDiagramEditor() {
 		return (DiagramEditor)getFeatureProvider().getDiagramTypeProvider().getDiagramBehavior().getDiagramContainer();
 	}
 }
	/*******************************************************************************
	* Copyright (c) 2011, 2012 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
	*
	* @author Ivar Meikas
	******************************************************************************/
	package org.eclipse.bpmn2.modeler.core.features;

	import org.eclipse.bpmn2.BaseElement;
	import org.eclipse.bpmn2.EndEvent;
	import org.eclipse.bpmn2.Lane;
	import org.eclipse.bpmn2.Participant;
	import org.eclipse.bpmn2.StartEvent;
	import org.eclipse.bpmn2.di.BPMNDiagram;
	import org.eclipse.bpmn2.di.BPMNEdge;
	import org.eclipse.bpmn2.di.BPMNShape;
	import org.eclipse.bpmn2.modeler.core.Activator;
	import org.eclipse.bpmn2.modeler.core.di.DIImport;
	import org.eclipse.bpmn2.modeler.core.di.DIUtils;
	import org.eclipse.bpmn2.modeler.core.features.flow.AbstractCreateFlowFeature;
	import org.eclipse.bpmn2.modeler.core.preferences.Bpmn2Preferences;
	import org.eclipse.bpmn2.modeler.core.preferences.ShapeStyle;
	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.ShapeDecoratorUtil;
	import org.eclipse.dd.dc.Bounds;
	import org.eclipse.graphiti.IExecutionInfo;
	import org.eclipse.graphiti.datatypes.ILocation;
	import org.eclipse.graphiti.features.IAddFeature;
	import org.eclipse.graphiti.features.ICreateConnectionFeature;
	import org.eclipse.graphiti.features.IFeatureProvider;
	import org.eclipse.graphiti.features.IReason;
	import org.eclipse.graphiti.features.IReconnectionFeature;
	import org.eclipse.graphiti.features.context.IAddConnectionContext;
	import org.eclipse.graphiti.features.context.IAddContext;
	import org.eclipse.graphiti.features.context.ITargetContext;
	import org.eclipse.graphiti.features.context.impl.AddContext;
	import org.eclipse.graphiti.features.context.impl.CreateConnectionContext;
	import org.eclipse.graphiti.features.context.impl.LayoutContext;
	import org.eclipse.graphiti.features.context.impl.ReconnectionContext;
	import org.eclipse.graphiti.features.context.impl.UpdateContext;
	import org.eclipse.graphiti.features.impl.AbstractAddPictogramElementFeature;
	import org.eclipse.graphiti.mm.GraphicsAlgorithmContainer;
	import org.eclipse.graphiti.mm.algorithms.RoundedRectangle;
	import org.eclipse.graphiti.mm.pictograms.Anchor;
	import org.eclipse.graphiti.mm.pictograms.AnchorContainer;
	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.FixPointAnchor;
	import org.eclipse.graphiti.mm.pictograms.PictogramElement;
	import org.eclipse.graphiti.mm.pictograms.Shape;
	import org.eclipse.graphiti.services.Graphiti;
	import org.eclipse.graphiti.services.IGaService;
	import org.eclipse.graphiti.services.ILayoutService;
	import org.eclipse.graphiti.services.IPeService;
	import org.eclipse.graphiti.ui.editor.DiagramEditor;

	/**
	* This is the Graphiti {@code AddFeature} base class for all BPMN2 model elements which
	* are associated with BPMN DI elements.
	* <p>
	* This class adds support for managing BPMN DI elements, i.e. BPMNShape and
	* BPMNEdge.
	* <p>
	* Note that the BPMNLabel element is not yet supported, but will be added in a
	* future release. For now, graphical shapes with labels are supported
	* indirectly outside the scope of BPMN DI.
	*
	* @param <T> the generic type, a subclass of {@link BaseElement}
	*/
	public abstract class AbstractBpmn2AddFeature<T extends BaseElement>
	extends AbstractAddPictogramElementFeature {

	/** The ga service. */
	protected final static IGaService gaService = Graphiti.getGaService();

	/** The pe service. */
	protected final static IPeService peService = Graphiti.getPeService();

	/** The preferences. */
	protected Bpmn2Preferences preferences;

	/**
	* Instantiates a new AddFeature.
	*
	* @param fp the Feature Provider instance
	*/
	public AbstractBpmn2AddFeature(IFeatureProvider fp) {
	super(fp);
	preferences = Bpmn2Preferences.getInstance(getDiagram());
	}

	public abstract IAddFeature getAddLabelFeature(IFeatureProvider fp);

	/**
	* Find the BPMNShape that references the given {@code BaseElement}.
	*
	* @param elem the BaseElement
	* @return the BPMNShape object if found or null if it has not been created yet.
	*/
	protected BPMNShape findDIShape(BaseElement elem) {
	try {
	return DIUtils.findBPMNShape(elem);
	} catch (Exception e) {
	Activator.logError(e);
	}
	return null;
	}

	/**
	* Creates a BPMNShape if it does not already exist, and then links it to
	* the given {@code BaseElement}.
	*
	* @param shape the Container Shape
	* @param elem the BaseElement
	* @param applyDefaults if true, apply User Preference defaults for certain
	* BPMN DI attributes, e.g. isHorizontal, isExpanded, etc.
	* @return the BPMNShape
	*/
	protected BPMNShape createDIShape(Shape shape, BaseElement elem, boolean applyDefaults) {
	BPMNShape bpmnShape = null;
	Diagram diagram = Graphiti.getPeService().getDiagramForShape(shape);
	if (diagram!=null) {
	BPMNDiagram bpmnDiagram = (BPMNDiagram) BusinessObjectUtil.getBusinessObjectForPictogramElement(diagram);
	bpmnShape = DIUtils.findBPMNShape(bpmnDiagram, elem);
	}
	else
	bpmnShape = findDIShape(elem);
	bpmnShape = DIUtils.createDIShape(shape, elem, bpmnShape, getFeatureProvider());
	if (applyDefaults && bpmnShape!=null)
	preferences.applyBPMNDIDefaults(bpmnShape, null);
	return bpmnShape;
	}

	/**
	* Creates a BPMNEdge if it does not already exist, and then links it to
	* the given {@code BaseElement}.
	*
	* @param connection the connection
	* @param elem the BaseElement
	* @return the BPMNEdge
	*/
	protected BPMNEdge createDIEdge(Connection connection, BaseElement elem) {
	BPMNDiagram bpmnDiagram = DIUtils.findBPMNDiagram(connection);
	BPMNEdge edge = DIUtils.findBPMNEdge(bpmnDiagram, elem);
	return DIUtils.createDIEdge(connection, elem, edge, getFeatureProvider());
	}

	/**
	* Adjust the location of a newly constructed shape so that its center is at
	* the mouse cursor position.
	*
	* @param context the AddContext
	* @param width the new shape's width
	* @param height the new shape's height
	*/
	protected void adjustLocation(IAddContext context, int width, int height) {
	if (DIImport.isImporting(context)) {
	return;
	}

	int x = context.getX();
	int y = context.getY();
	((AddContext)context).setWidth(width);
	((AddContext)context).setHeight(height);

	y -= height/2;
	x -= width / 2;
	((AddContext)context).setY(y);
	((AddContext)context).setX(x);
	}

	/**
	* Split a connection. This is used when a shape is dropped onto a
	* connection; the target of the original connection is attached to the new
	* shape, and a new connection is created that connects the new shape to the
	* old connection's target.
	*
	* @param context the AddContext for the new shape. This will have the
	* target connection which needs to be split
	* @param containerShape the new container shape that was dropped onto the
	* connection
	*/
	protected void splitConnection(IAddContext context, ContainerShape containerShape) {
	if (context.getProperty(GraphitiConstants.IMPORT_PROPERTY) != null) {
	return;
	}

	Object newObject = getBusinessObject(context);
	Connection connection = context.getTargetConnection();
	if (connection!=null) {
	// determine how to split the line depending on where the new object was dropped:
	// the longer segment will remain the original connection, and a new connection
	// will be created for the shorter segment
	ILayoutService layoutService = Graphiti.getLayoutService();
	Anchor a0 = connection.getStart();
	Anchor a1 = connection.getEnd();
	double x0 = layoutService.getLocationRelativeToDiagram(a0).getX();
	double y0 = layoutService.getLocationRelativeToDiagram(a0).getY();
	double x1 = layoutService.getLocationRelativeToDiagram(a1).getX();
	double y1 = layoutService.getLocationRelativeToDiagram(a1).getY();
	double dx = x0 - context.getX();
	double dy = y0 - context.getY();
	double len0 = Math.sqrt(dxdx + dydy);
	dx = context.getX() - x1;
	dy = context.getY() - y1;
	double len1 = Math.sqrt(dxdx + dydy);

	AnchorContainer oldSourceContainer = connection.getStart().getParent();
	AnchorContainer oldTargetContainer = connection.getEnd().getParent();
	BaseElement baseElement = BusinessObjectUtil.getFirstElementOfType(connection, BaseElement.class);
	ILocation targetLocation = layoutService.getLocationRelativeToDiagram(containerShape);

	ReconnectionContext rc;
	FixPointAnchor anchor;

	if (newObject instanceof StartEvent \|\| (len0 < len1 && !(newObject instanceof EndEvent))) {
	anchor = AnchorUtil.createAnchor(containerShape, GraphicsUtil.getShapeCenter(oldTargetContainer));
	rc = new ReconnectionContext(connection, connection.getStart(), anchor, targetLocation);
	rc.setReconnectType(ReconnectionContext.RECONNECT_SOURCE);
	rc.setTargetPictogramElement(containerShape);
	}
	else {
	anchor = AnchorUtil.createAnchor(containerShape, GraphicsUtil.getShapeCenter(containerShape));
	rc = new ReconnectionContext(connection, connection.getEnd(), anchor, targetLocation);
	rc.setReconnectType(ReconnectionContext.RECONNECT_TARGET);
	rc.setTargetPictogramElement(containerShape);
	}
	IReconnectionFeature rf = getFeatureProvider().getReconnectionFeature(rc);
	rf.reconnect(rc);

	if (!(newObject instanceof EndEvent) && !(newObject instanceof StartEvent)) {
	// connection = get create feature, create connection
	CreateConnectionContext ccc = new CreateConnectionContext();
	if (len0 < len1) {
	ccc.setSourcePictogramElement(oldSourceContainer);
	ccc.setTargetPictogramElement(containerShape);
	anchor = AnchorUtil.createAnchor(oldSourceContainer, GraphicsUtil.getShapeCenter(containerShape));
	ccc.setSourceAnchor(anchor);
	anchor = AnchorUtil.createAnchor(containerShape, GraphicsUtil.getShapeCenter(oldTargetContainer));
	ccc.setTargetAnchor(anchor);
	}
	else {
	ccc.setSourcePictogramElement(containerShape);
	ccc.setTargetPictogramElement(oldTargetContainer);
	anchor = AnchorUtil.createAnchor(containerShape, GraphicsUtil.getShapeCenter(oldTargetContainer));
	ccc.setSourceAnchor(anchor);
	anchor = AnchorUtil.createAnchor(oldTargetContainer, GraphicsUtil.getShapeCenter(containerShape));
	ccc.setTargetAnchor(anchor);
	}

	Connection newConnection = null;
	ICreateConnectionFeature ccf = AbstractCreateFlowFeature.getCreateFeature(getFeatureProvider(), ccc, baseElement);
	if (ccf!=null)
	newConnection = ccf.create(ccc);
	DIUtils.updateDIEdge(newConnection);
	}
	DIUtils.updateDIEdge(connection);
	}
	}

	/**
	* Gets the height of a new shape based on User Preferences. If the shape is a copy of
	* another shape, the height of the copied shape is used.
	*
	* @param context the AddContext for the new shape
	* @return the height
	*/
	protected int getHeight(IAddContext context) {
	Object copiedBpmnShape = context.getProperty(GraphitiConstants.COPIED_BPMN_DI_ELEMENT);
	if (copiedBpmnShape instanceof BPMNShape) {
	Bounds b = ((BPMNShape)copiedBpmnShape).getBounds();
	if (b!=null)
	// if (isHorizontal(context))
	// return (int) b.getWidth();
	return (int) b.getHeight();
	}
	if (context.getHeight() > 0)
	return context.getHeight();
	if (context.getProperty(GraphitiConstants.IMPORT_PROPERTY) == null) {
	if (isHorizontal(context)) {
	if (context.getWidth() > 0)
	return context.getWidth();
	return getWidth();
	}
	}
	return getHeight();
	}

	/**
	* Gets the width of a new shape based on User Preferences. If the shape is a copy of
	* another shape, the width of the copied shape is used.
	*
	* @param context the AddContext for the new shape
	* @return the width
	*/
	protected int getWidth(IAddContext context) {
	Object copiedBpmnShape = context.getProperty(GraphitiConstants.COPIED_BPMN_DI_ELEMENT);
	if (copiedBpmnShape instanceof BPMNShape) {
	Bounds b = ((BPMNShape)copiedBpmnShape).getBounds();
	if (b!=null) {
	// if (isHorizontal(context))
	// return (int) b.getHeight();
	return (int) b.getWidth();
	}
	}
	if (context.getWidth() > 0)
	return context.getWidth();
	if (context.getProperty(GraphitiConstants.IMPORT_PROPERTY) == null) {
	if (isHorizontal(context)) {
	if (context.getHeight() > 0)
	return context.getHeight();
	return getHeight();
	}
	}
	return getWidth();
	}

	/**
	* Gets the height.
	*
	* @return the height
	*/
	protected int getHeight() {
	ShapeStyle ss = preferences.getShapeStyle(getBusinessObjectType());
	return ss.getDefaultHeight();
	}

	/**
	* Gets the width.
	*
	* @return the width
	*/
	protected int getWidth() {
	ShapeStyle ss = preferences.getShapeStyle(getBusinessObjectType());
	return ss.getDefaultWidth();
	}

	/**
	* Checks User Preferences if horizontal layout is preferred.
	*
	* @param context the context
	* @return true, if is horizontal
	*/
	protected boolean isHorizontal(ITargetContext context) {
	// isHorizontal only applies to Lanes and Pools
	if (context instanceof IAddContext) {
	Object newObject = ((IAddContext)context).getNewObject();
	if (!(newObject instanceof Lane) && !(newObject instanceof Participant))
	return false;
	}
	if (context.getProperty(GraphitiConstants.IMPORT_PROPERTY) == null) {
	// not importing - set isHorizontal to be the same as copied element or parent
	Object copiedBpmnShape = context.getProperty(GraphitiConstants.COPIED_BPMN_DI_ELEMENT);
	if (copiedBpmnShape instanceof BPMNShape) {
	return ((BPMNShape)copiedBpmnShape).isIsHorizontal();
	}

	if (FeatureSupport.isTargetParticipant(context)) {
	Participant targetParticipant = FeatureSupport.getTargetParticipant(context);
	BPMNShape participantShape = findDIShape(targetParticipant);
	if (participantShape!=null)
	return participantShape.isIsHorizontal();
	}
	else if (FeatureSupport.isTargetLane(context)) {
	Lane targetLane = FeatureSupport.getTargetLane(context);
	BPMNShape laneShape = findDIShape(targetLane);
	if (laneShape!=null)
	return laneShape.isIsHorizontal();
	}
	}
	return FeatureSupport.isHorizontal(context);
	}

	public abstract Class<? extends BaseElement> getBusinessObjectType();

	public T getBusinessObject(IAddContext context) {
	Object businessObject = context.getProperty(GraphitiConstants.BUSINESS_OBJECT);
	if (businessObject instanceof BaseElement)
	return (T)businessObject;
	return (T)context.getNewObject();
	}

	public void putBusinessObject(IAddContext context, T businessObject) {
	context.putProperty(GraphitiConstants.BUSINESS_OBJECT, businessObject);
	}

	public void postExecute(IExecutionInfo executionInfo) {
	}

	/**
	* Helper function to return the GraphicsAlgorithm for a ContainerShape created by
	* one of the BPMN2 Modeler's Add features. This can be used by subclasses to decorate
	* the figure on the diagram.
	*
	* @param containerShape the container shape
	* @return the graphics algorithm
	*/
	protected static GraphicsAlgorithmContainer getGraphicsAlgorithm(ContainerShape containerShape) {
	if (containerShape.getGraphicsAlgorithm() instanceof RoundedRectangle)
	return containerShape.getGraphicsAlgorithm();
	if (containerShape.getChildren().size()>0) {
	Shape shape = containerShape.getChildren().get(0);
	return shape.getGraphicsAlgorithm();
	}
	return null;
	}

	/**
	* Decorate connection. This is a placeholder for the hook function invoked
	* when the connection is added to the diagram. Implementations can override
	* this to change the appearance of the connection.
	*
	* @param context the Add Context
	* @param connection the connection being added
	* @param businessObject the business object, a {@code BaseElement} subclass.
	*/
	protected void decorateConnection(IAddConnectionContext context, Connection connection, T businessObject) {
	}

	/**
	* Decorate shape. This is a placeholder for the hook function invoked when
	* the shape is added to the diagram. Implementations can override this to
	* change the appearance of the shape.
	*
	* @param context the Add Context
	* @param containerShape the container shape being added
	* @param businessObject the business object, a {@code BaseElement} subclass.
	*/
	protected void decorateShape(IAddContext context, ContainerShape containerShape, T businessObject) {
	ShapeDecoratorUtil.createValidationDecorator(containerShape);
	}

	/**
	* Update the given PictogramElement. A Graphiti UpdateContext is constructed by copying
	* the properties from the given AddContext.
	*
	* @param addContext the Graphiti AddContext that was used to add the PE to the Diagram
	* @param pe the PictogramElement
	* @return a reason code indicating whether or not an update is needed.
	*/
	public IReason updatePictogramElement(IAddContext addContext, PictogramElement pe) {
	UpdateContext updateContext = new UpdateContext(pe);
	for (Object key : addContext.getPropertyKeys()) {
	Object value = addContext.getProperty(key);
	updateContext.putProperty(key, value);
	}
	return getFeatureProvider().updateIfPossible(updateContext);
	}

	/**
	* Layout the given PictogramElement. A Graphiti LayoutContext is constructed by copying
	* the properties from the given AddContext.
	*
	* @param addContext the Graphiti AddContext that was used to add the PE to the Diagram
	* @param pe the PictogramElement
	* @return a reason code indicating whether or not a layout is needed.
	*/
	public IReason layoutPictogramElement(IAddContext addContext, PictogramElement pe) {
	LayoutContext layoutContext = new LayoutContext(pe);
	for (Object key : addContext.getPropertyKeys()) {
	Object value = addContext.getProperty(key);
	layoutContext.putProperty(key, value);
	}
	return getFeatureProvider().layoutIfPossible(layoutContext);
	}

	protected DiagramEditor getDiagramEditor() {
	return (DiagramEditor)getFeatureProvider().getDiagramTypeProvider().getDiagramBehavior().getDiagramContainer();
	}
	}