plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/policy/BendpointEditPolicyFixed.java

/*******************************************************************************
 * Copyright (c) 2000, 2005 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 API and implementation
 *     SAP AG - Changed for initial API, implementation and documentation of Graphiti:
 *     		made fields NULL_CONSTRAINT, originalConstraint, isDeleting, ref1, ref2 protected
 *     		made methods protected:
 *     			createHandlesForAutomaticBendpoints
 *     			createHandlesForUserBendpoints
 *     			isAutomaticallyBending
 *     			lineContainsPoint
 *     			setReferencePoints
 *     		added
 *     			getConfigurationProvider
 *     			getFeatureProvider
 *     			setConfigurationProvider
 *     			checkMoveAndRemoveBendpointFeature
 *     			checkCreateBendpointFeature 
 *******************************************************************************/
// ****************************************************************************
// ****************************************************************************
//           THIS CLASS IS MOSTLY COPIED FROM BendpointEditPolicy
//        BUT EVERYTHING IS protected, SO THAT IT CAN BE OVERWRITTEN
// ****************************************************************************
// ****************************************************************************

package org.eclipse.graphiti.ui.internal.policy;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.draw2d.AbsoluteBendpoint;
import org.eclipse.draw2d.AutomaticRouter;
import org.eclipse.draw2d.Bendpoint;
import org.eclipse.draw2d.Connection;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.ConnectionEditPart;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.Request;
import org.eclipse.gef.commands.Command;
import org.eclipse.gef.editpolicies.SelectionHandlesEditPolicy;
import org.eclipse.gef.handles.BendpointCreationHandle;
import org.eclipse.gef.handles.BendpointHandle;
import org.eclipse.gef.handles.BendpointMoveHandle;
import org.eclipse.gef.requests.BendpointRequest;
import org.eclipse.graphiti.features.IFeatureProvider;
import org.eclipse.graphiti.features.context.impl.MoveBendpointContext;
import org.eclipse.graphiti.features.context.impl.RemoveBendpointContext;
import org.eclipse.graphiti.internal.services.GraphitiInternal;
import org.eclipse.graphiti.mm.pictograms.FreeFormConnection;
import org.eclipse.graphiti.ui.internal.config.IConfigurationProviderInternal;

/**
 * Used to add bendpoint handles on a {@link ConnectionEditPart}.
 * <P>
 * BendpointEditPolicy will automatically observe the
 * {@link org.eclipse.draw2d.Connection} figure. If the number of bends in the
 * <code>Connection</code> changes, the handles will be updated.
 * 
 * @noinstantiate This class is not intended to be instantiated by clients.
 * @noextend This class is not intended to be subclassed by clients.
 */
public abstract class BendpointEditPolicyFixed extends SelectionHandlesEditPolicy implements PropertyChangeListener {

	protected static final List<Bendpoint> NULL_CONSTRAINT = new ArrayList<Bendpoint>();

	// CHANGED: make fields protected
	protected List<?> originalConstraint;
	protected boolean isDeleting = false;

	private IConfigurationProviderInternal configurationProvider;

	protected static final Point ref1 = new Point();
	protected static final Point ref2 = new Point();

	public BendpointEditPolicyFixed(IConfigurationProviderInternal configurationProvider) {
		super();
		setConfigurationProvider(configurationProvider);
	}

	/**
	 * <code>activate()</code> is extended to add a listener to the
	 * <code>Connection</code> figure.
	 * 
	 * @see org.eclipse.gef.EditPolicy#activate()
	 */
	@Override
	public void activate() {
		super.activate();
		getConnection().addPropertyChangeListener(Connection.PROPERTY_POINTS, this);
	}

	protected List<BendpointHandle> createHandlesForAutomaticBendpoints() {
		List<BendpointHandle> list = new ArrayList<BendpointHandle>();
		ConnectionEditPart connEP = (ConnectionEditPart) getHost();
		PointList points = getConnection().getPoints();
		for (int i = 0; i < points.size() - 1; i++)
			list.add(new BendpointCreationHandle(connEP, 0, i));

		return list;
	}

	protected List<BendpointHandle> createHandlesForUserBendpoints() {
		List<BendpointHandle> list = new ArrayList<BendpointHandle>();
		ConnectionEditPart connEP = (ConnectionEditPart) getHost();
		PointList points = getConnection().getPoints();
		List<?> bendPoints = (List<?>) getConnection().getRoutingConstraint();
		int bendPointIndex = 0;
		Point currBendPoint = null;

		if (bendPoints == null) {
			bendPoints = NULL_CONSTRAINT;
		} else if (!bendPoints.isEmpty()) {
			currBendPoint = ((Bendpoint) bendPoints.get(0)).getLocation();
		}

		for (int i = 0; i < points.size() - 1; i++) {
			if (checkCreateBendpointFeature()) {
				// Put a create handle on the middle of every segment
				list.add(new BendpointCreationHandle(connEP, bendPointIndex, i));
			}

			// If the current user bendpoint matches a bend location, show a
			// move handle
			if (i < points.size() - 1 && bendPointIndex < bendPoints.size() && currBendPoint.equals(points.getPoint(i + 1))) {
				if (checkMoveAndRemoveBendpointFeature()) {
					list.add(new BendpointMoveHandle(connEP, bendPointIndex, i + 1));
				}
				// Go to the next user bendpoint
				bendPointIndex++;
				if (bendPointIndex < bendPoints.size()) {
					currBendPoint = ((Bendpoint) bendPoints.get(bendPointIndex)).getLocation();
				}
			}
		}

		return list;
	}

	/**
	 * Creates selection handles for the bendpoints. Explicit (user-defined)
	 * bendpoints will have {@link BendpointMoveHandle}s on them with a single
	 * {@link BendpointCreationHandle} between 2 consecutive explicit
	 * bendpoints. If implicit bendpoints (such as those created by the
	 * {@link AutomaticRouter}) are used, one {@link BendpointCreationHandle} is
	 * placed in the middle of the Connection.
	 * 
	 * @see SelectionHandlesEditPolicy#createSelectionHandles()
	 */
	@Override
	protected List<BendpointHandle> createSelectionHandles() {
		List<BendpointHandle> list = new ArrayList<BendpointHandle>();
		boolean automaticallyBending = isAutomaticallyBending();
		if (automaticallyBending) {
			list = createHandlesForAutomaticBendpoints();
		} else {
			list = createHandlesForUserBendpoints();
		}
		return list;
	}

	/**
	 * <code>deactivate()</code> is extended to remove the property change
	 * listener on the <code>Connection</code> figure.
	 * 
	 * @see org.eclipse.gef.EditPolicy#deactivate()
	 */
	@Override
	public void deactivate() {
		getConnection().removePropertyChangeListener(Connection.PROPERTY_POINTS, this);
		super.deactivate();
	}

	/**
	 * Erases all bendpoint feedback. Since the original <code>Connection</code>
	 * figure is used for feedback, we just restore the original constraint that
	 * was saved before feedback started to show.
	 * 
	 * @param request
	 *            the BendpointRequest
	 */
	protected void eraseConnectionFeedback(BendpointRequest request) {
		restoreOriginalConstraint();
		request.getSource().refresh();
		originalConstraint = null;
	}

	/**
	 * @see org.eclipse.gef.EditPolicy#eraseSourceFeedback(Request)
	 */
	@Override
	public void eraseSourceFeedback(Request request) {
		if (REQ_MOVE_BENDPOINT.equals(request.getType()) || REQ_CREATE_BENDPOINT.equals(request.getType()))
			eraseConnectionFeedback((BendpointRequest) request);
	}

	/**
	 * Factors the Request into either a MOVE, a DELETE, or a CREATE of a
	 * bendpoint.
	 * 
	 * @see org.eclipse.gef.EditPolicy#getCommand(Request)
	 */
	@Override
	public Command getCommand(Request request) {
		if (REQ_MOVE_BENDPOINT.equals(request.getType())) {
			if (isDeleting) {
				return getDeleteBendpointCommand((BendpointRequest) request);
			}
			return getMoveBendpointCommand((BendpointRequest) request);
		}
		if (REQ_CREATE_BENDPOINT.equals(request.getType())) {
			return getCreateBendpointCommand((BendpointRequest) request);
		}
		return null;
	}

	/**
	 * Convenience method for obtaining the host's <code>Connection</code>
	 * figure.
	 * 
	 * @return the Connection figure
	 */
	protected Connection getConnection() {
		return (Connection) ((ConnectionEditPart) getHost()).getFigure();
	}

	/**
	 * Implement this method to return a Command that will create a bendpoint.
	 * 
	 * @param request
	 *            the BendpointRequest
	 * @return a Command to create a bendpoint
	 */
	protected abstract Command getCreateBendpointCommand(BendpointRequest request);

	/**
	 * Implement this method to return a Command that will delete a bendpoint.
	 * 
	 * @param request
	 *            the BendpointRequest
	 * @return a Command to delete a bendpoint
	 */
	protected abstract Command getDeleteBendpointCommand(BendpointRequest request);

	/**
	 * Implement this method to return a Command that will move a bendpoint.
	 * 
	 * @param request
	 *            the BendpointRequest
	 * @return a Command to move a bendpoint
	 */
	protected abstract Command getMoveBendpointCommand(BendpointRequest request);

	protected boolean isAutomaticallyBending() {
		List<?> constraint = (List<?>) getConnection().getRoutingConstraint();
		PointList points = getConnection().getPoints();
		return ((points.size() > 2) && (constraint == null || constraint.isEmpty()));
	}

	protected boolean lineContainsPoint(Point p1, Point p2, Point p) {
		int tolerance = 7;
		Rectangle rect = Rectangle.SINGLETON;
		rect.setSize(0, 0);
		rect.setLocation(p1.x, p1.y);
		rect.union(p2.x, p2.y);
		rect.expand(tolerance, tolerance);
		if (!rect.contains(p.x, p.y))
			return false;

		int v1x, v1y, v2x, v2y;
		int numerator, denominator;
		double result = 0.0;

		if (p1.x != p2.x && p1.y != p2.y) {

			v1x = p2.x - p1.x;
			v1y = p2.y - p1.y;
			v2x = p.x - p1.x;
			v2y = p.y - p1.y;

			numerator = v2x * v1y - v1x * v2y;
			denominator = v1x * v1x + v1y * v1y;

			result = ((numerator << 10) / denominator * numerator) >> 10;
		}

		// if it is the same point, and it passes the bounding box test,
		// the result is always true.
		return result <= tolerance * tolerance;
	}

	/**
	 * If the number of bendpoints changes, handles are updated.
	 * 
	 * @see java.beans.PropertyChangeListener#propertyChange(PropertyChangeEvent)
	 */
	public void propertyChange(PropertyChangeEvent evt) {
		// $TODO optimize so that handles aren't added constantly.
		if (getHost().getSelected() != EditPart.SELECTED_NONE)
			addSelectionHandles();
	}

	/**
	 * Restores the original constraint that was saved before feedback began to
	 * show.
	 */
	protected void restoreOriginalConstraint() {
		if (originalConstraint != null) {
			if (originalConstraint == NULL_CONSTRAINT)
				getConnection().setRoutingConstraint(null);
			else
				getConnection().setRoutingConstraint(originalConstraint);
		}
	}

	/**
	 * Since the original figure is used for feedback, this method saves the
	 * original constraint, so that is can be restored when the feedback is
	 * erased.
	 */
	protected void saveOriginalConstraint() {
		originalConstraint = (List<?>) getConnection().getRoutingConstraint();
		if (originalConstraint == null)
			originalConstraint = NULL_CONSTRAINT;
		getConnection().setRoutingConstraint(new ArrayList<Object>(originalConstraint));
	}

	protected void setReferencePoints(BendpointRequest request) {
		PointList points = getConnection().getPoints();
		int bpIndex = -1;
		List<?> bendPoints = (List<?>) getConnection().getRoutingConstraint();
		Point bp = ((Bendpoint) bendPoints.get(request.getIndex())).getLocation();

		double smallestDistance = -1;

		for (int i = 0; i < points.size(); i++) {
			double dist = points.getPoint(i).getDistance(bp);
			if (smallestDistance == -1 || dist < smallestDistance) {
				bpIndex = i;
				smallestDistance = dist;
				if (smallestDistance == 0)
					break; 
			}
		}

		points.getPoint(ref1, bpIndex - 1);
		getConnection().translateToAbsolute(ref1);
		points.getPoint(ref2, bpIndex + 1);
		getConnection().translateToAbsolute(ref2);
	}

	/**
	 * Shows feedback when a bendpoint is being created. The original figure is
	 * used for feedback and the original constraint is saved, so that it can be
	 * restored when feedback is erased.
	 * 
	 * @param request
	 *            the BendpointRequest
	 */
	protected void showCreateBendpointFeedback(BendpointRequest request) {
		Point p = new Point(request.getLocation());
		List<Bendpoint> constraint;
		getConnection().translateToRelative(p);
		Bendpoint bp = new AbsoluteBendpoint(p);
		if (originalConstraint == null) {
			saveOriginalConstraint();
			constraint = getConnectionRoutingConstraint();
			constraint.add(request.getIndex(), bp);
		} else {
			constraint = getConnectionRoutingConstraint();
		}
		constraint.set(request.getIndex(), bp);
		getConnection().setRoutingConstraint(constraint);
	}

	/**
	 * Shows feedback when a bendpoint is being deleted. This method is only
	 * called once when the bendpoint is first deleted, not every mouse move.
	 * The original figure is used for feedback and the original constraint is
	 * saved, so that it can be restored when feedback is erased.
	 * 
	 * @param request
	 *            the BendpointRequest
	 */
	protected void showDeleteBendpointFeedback(BendpointRequest request) {
		if (originalConstraint == null) {
			saveOriginalConstraint();
			List<?> constraint = (List<?>) getConnection().getRoutingConstraint();
			constraint.remove(request.getIndex());
			getConnection().setRoutingConstraint(constraint);
		}
	}

	/**
	 * Shows feedback when a bendpoint is being moved. Also checks to see if the
	 * bendpoint should be deleted and then calls
	 * {@link #showDeleteBendpointFeedback(BendpointRequest)} if needed. The
	 * original figure is used for feedback and the original constraint is
	 * saved, so that it can be restored when feedback is erased.
	 * 
	 * @param request
	 *            the BendpointRequest
	 */
	protected void showMoveBendpointFeedback(BendpointRequest request) {
		Point p = new Point(request.getLocation());
		if (!isDeleting)
			setReferencePoints(request);

		if (lineContainsPoint(ref1, ref2, p)) {
			if (!isDeleting) {
				isDeleting = true;
				eraseSourceFeedback(request);
				showDeleteBendpointFeedback(request);
			}
			return;
		}
		if (isDeleting) {
			isDeleting = false;
			eraseSourceFeedback(request);
		}
		if (originalConstraint == null)
			saveOriginalConstraint();
		List<Bendpoint> constraint = getConnectionRoutingConstraint();
		getConnection().translateToRelative(p);
		Bendpoint bp = new AbsoluteBendpoint(p);
		constraint.set(request.getIndex(), bp);
		getConnection().setRoutingConstraint(constraint);
	}

	/**
	 * Shows feedback when appropriate. Calls a different method depending on
	 * the request type.
	 * 
	 * @see #showCreateBendpointFeedback(BendpointRequest)
	 * @see #showMoveBendpointFeedback(BendpointRequest)
	 * @param request
	 *            the Request
	 */
	@Override
	public void showSourceFeedback(Request request) {
		if (REQ_MOVE_BENDPOINT.equals(request.getType()))
			showMoveBendpointFeedback((BendpointRequest) request);
		else if (REQ_CREATE_BENDPOINT.equals(request.getType()))
			showCreateBendpointFeedback((BendpointRequest) request);
	}

	protected IConfigurationProviderInternal getConfigurationProvider() {
		return configurationProvider;
	}

	protected IFeatureProvider getFeatureProvider() {
		if (getConfigurationProvider() != null) {
			return getConfigurationProvider().getFeatureProvider();
		}
		return null;
	}

	private void setConfigurationProvider(IConfigurationProviderInternal configurationProvider) {
		this.configurationProvider = configurationProvider;
	}

	private boolean checkMoveAndRemoveBendpointFeature() {
		if (!(getConnection() instanceof FreeFormConnection)) {
			return true;
		}

		boolean ret = false;
		FreeFormConnection ffc = (FreeFormConnection) getConnection();
		if (!GraphitiInternal.getEmfService().isObjectAlive(ffc)) {
			return ret;
		}

		ret = (null != getFeatureProvider().getMoveBendpointFeature(new MoveBendpointContext(null)));
		ret = ret || (null != getFeatureProvider().getRemoveBendpointFeature(new RemoveBendpointContext(ffc, null)));
		return ret;
	}

	private boolean checkCreateBendpointFeature() {
		if (!(getConnection() instanceof FreeFormConnection)) {
			return true;
		}

		boolean ret = false;
		FreeFormConnection ffc = (FreeFormConnection) getConnection();
		if (!GraphitiInternal.getEmfService().isObjectAlive(ffc)) {
			return ret;
		}

		ret = (null != getFeatureProvider().getMoveBendpointFeature(new MoveBendpointContext(null)));
		return ret;
	}
	
	protected List<Bendpoint> getConnectionRoutingConstraint() {
		Object rawRoutingConstraint = getConnection().getRoutingConstraint();
		
		@SuppressWarnings("unchecked")
		List<Bendpoint> ret = (List<Bendpoint>) rawRoutingConstraint;

		return ret;
	}


}