plugins/org.eclipse.gmf.tooling.runtime/src/org/eclipse/gmf/tooling/runtime/linklf/SlidableSnapToGridAnchor.java - gerrit/gmf-tooling/org.eclipse.gmf-tooling - Git at Google

 /*****************************************************************************
  * Copyright (c) 2014-15 CEA LIST, Montages AG 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:
  *   Michael Golubev (Montages) - Initial API and implementation
  *
  *****************************************************************************/
 package org.eclipse.gmf.tooling.runtime.linklf;

 import java.util.Collection;
 import java.util.LinkedList;
 import java.util.List;

 import org.eclipse.draw2d.PositionConstants;
 import org.eclipse.draw2d.geometry.Point;
 import org.eclipse.draw2d.geometry.PrecisionPoint;
 import org.eclipse.draw2d.geometry.PrecisionRectangle;
 import org.eclipse.draw2d.geometry.Rectangle;
 import org.eclipse.gef.EditPartViewer;
 import org.eclipse.gmf.runtime.draw2d.ui.figures.FigureUtilities;
 import org.eclipse.gmf.runtime.gef.ui.figures.NodeFigure;
 import org.eclipse.gmf.runtime.gef.ui.figures.SlidableAnchor;

 /**
  * Extends {@link SlidableAnchor} with ability to snap to the intersection
  * points between the host anchorable bounds and the active diagram grid.
  *
  * @since 3.3
  */
 public class SlidableSnapToGridAnchor extends SlidableAnchor {

 	private EditPartViewer myGridProvider;

 	public SlidableSnapToGridAnchor(NodeFigure f, PrecisionPoint p) {
 		super(f, p);
 	}

 	public void setEditPartViewer(EditPartViewer viewer) {
 		myGridProvider = viewer;
 	}

 	@Override
 	public Point getOrthogonalLocation(Point orthoReference) {
 		Point result = getOrthogonalLocationNoSnap(orthoReference);
 		if (result != null) {
 			Rectangle gridSpecAbs = getAbsoluteGridSpec();
 			LinkedList<Point> onVerticalGrid = new LinkedList<Point>();
 			LinkedList<Point> onHorizontalGrid = new LinkedList<Point>();
 			computeAnchorablePointsOnGrid(gridSpecAbs, onVerticalGrid,
 					onHorizontalGrid);

 			if (!onHorizontalGrid.isEmpty() || !onVerticalGrid.isEmpty()) {
 				return pickClosestPointToSet(result, onHorizontalGrid,
 						onVerticalGrid);
 			}
 		}
 		return result;
 	}

 	private boolean myGetLocationReentryLock = false;

 	@Override
 	public Point getLocation(Point reference) {
 		Rectangle gridSpecAbs = getAbsoluteGridSpec();
 		if (gridSpecAbs != null && !myGetLocationReentryLock) {
 			myGetLocationReentryLock = true;
 			try {
 				List<Point> onVerticalGrid = new LinkedList<Point>();
 				List<Point> onHorizontalGrid = new LinkedList<Point>();

 				computeAnchorablePointsOnGrid(gridSpecAbs, onVerticalGrid,
 						onHorizontalGrid);

 				if (!onVerticalGrid.isEmpty() || !onVerticalGrid.isEmpty()) {
 					return pickClosestPointToSet(getReferencePoint(),
 							onHorizontalGrid, onVerticalGrid);
 				}
 			} finally {
 				myGetLocationReentryLock = false;
 			}
 		}

 		Point result = super.getLocation(reference);
 		return result;
 	}

 	/**
 	 * @see bug #451604, we don't want anchor to move even if the resulting line
 	 *      is close to straight
 	 *      <p/>
 	 *      So we will block the normalization for instances of this class.
 	 */
 	@Override
 	protected Point normalizeToStraightlineTolerance(Point foreignReference,
 			Point ownReference, int tolerance) {
 		final int NO_TOLERANCE = 0;
 		return super.normalizeToStraightlineTolerance(foreignReference,
 				ownReference, NO_TOLERANCE);
 	}

 	@Override
 	public String toString() {
 		return "SSTGA:" + "terminal: " + getTerminal() + ", terminalLoc: "
 				+ getReferencePoint() + ", box: " + getBox();
 	}

 	/**
 	 * Returns the position of the closest edge of the rectangle closest to the
 	 * point
 	 *
 	 * @param p
 	 *            the point
 	 * @param r
 	 *            the rectangle
 	 * @return position of the closest edge
 	 * @deprecated copy-pasted from super class, [GMFRT] make protected
 	 */
 	@Deprecated
 	public static int getClosestSide2(Point p, Rectangle r) {
 		double diff = Math.abs(r.preciseX() + r.preciseWidth() - p.preciseX());
 		int side = PositionConstants.RIGHT;
 		double currentDiff = Math.abs(r.preciseX() - p.preciseX());
 		if (currentDiff < diff) {
 			diff = currentDiff;
 			side = PositionConstants.LEFT;
 		}
 		currentDiff = Math.abs(r.preciseY() + r.preciseHeight() - p.preciseY());
 		if (currentDiff < diff) {
 			diff = currentDiff;
 			side = PositionConstants.BOTTOM;
 		}
 		currentDiff = Math.abs(r.preciseY() - p.preciseY());
 		if (currentDiff < diff) {
 			diff = currentDiff;
 			side = PositionConstants.TOP;
 		}
 		return side;
 	}

 	/**
 	 * If grid provider had been set up and has grid enabled then returns active
 	 * grid specification in absolute coordinates. Otherwise returns null.
 	 *
 	 * @return <code>null</code> if no active grid or grid provider had not been
 	 *         set up.
 	 */
 	protected Rectangle getAbsoluteGridSpec() {
 		return myGridProvider == null ? null : DiagramGridSpec
 				.getAbsoluteGridSpec(myGridProvider);
 	}

 	protected static Point pickClosestPointToSet(Point source,
 			Collection<? extends Point> set1, Collection<? extends Point> set2) {
 		double bestDistSquared = Double.MAX_VALUE;
 		Point result = null;
 		for (Point next : set1) {
 			double nextDistSquared = source.getDistance(next);
 			if (nextDistSquared < bestDistSquared) {
 				result = next;
 				bestDistSquared = nextDistSquared;
 			}
 		}
 		for (Point next : set2) {
 			double nextDistSquared = source.getDistance(next);
 			if (nextDistSquared < bestDistSquared) {
 				result = next;
 				bestDistSquared = nextDistSquared;
 			}
 		}
 		return result;
 	}

 	/**
 	 * Computes possible anchorable points on grid for given gridSpec. Results
 	 * are pushed into the given lists, separately for points computed for
 	 * vertical and horizontal grid.
 	 * <p/>
 	 * As results of this method depends only on the owner location and the
 	 * gridspec, they may be cached to improve performance.
 	 *
 	 * @param gridSpecAbs
 	 *            absolute grid specification, if <code>null</code> then method
 	 *            does nothing
 	 * @param onVerticalGridLocs
 	 *            output list to store points of vertical grid
 	 * @param onHorizontalGridLocs
 	 *            output list to store points on horizontal grid
 	 */
 	protected void computeAnchorablePointsOnGrid(Rectangle gridSpecAbs,
 			List<Point> onVerticalGridLocs, List<Point> onHorizontalGridLocs) {
 		if (gridSpecAbs == null) {
 			return;
 		}
 		double gridX = gridSpecAbs.preciseWidth();
 		double gridY = gridSpecAbs.preciseWidth();
 		Point gridOrigin = gridSpecAbs.getLocation();

 		PrecisionRectangle bounds = new PrecisionRectangle(
 				FigureUtilities.getAnchorableFigureBounds(getOwner()));
 		getOwner().translateToAbsolute(bounds);

 		Point notOnGrid = bounds.getCenter();

 		PrecisionPoint fakeRefAbove = new PrecisionPoint(notOnGrid);
 		PrecisionPoint fakeRefBelow = new PrecisionPoint(notOnGrid);
 		fakeRefAbove
 				.setPreciseY(bounds.preciseY() - bounds.preciseHeight() / 2);
 		fakeRefBelow.setPreciseY(bounds.preciseY() + bounds.preciseHeight() / 2
 				+ bounds.preciseHeight());

 		double reminderX = Math.IEEEremainder(
 				notOnGrid.preciseX() - gridOrigin.preciseX(), gridX);
 		if (reminderX < 0) {
 			reminderX += gridX;
 		}
 		for (double nextX = notOnGrid.preciseX() - reminderX; nextX >= bounds
 				.preciseX(); nextX -= gridX) {
 			fakeRefAbove.setPreciseX(nextX);
 			fakeRefBelow.setPreciseX(nextX);
 			Point onGridForAboveRef = getOrthogonalLocationNoSnap(fakeRefAbove);
 			Point onGridForBelowRef = getOrthogonalLocationNoSnap(fakeRefBelow);
 			onVerticalGridLocs.add(onGridForAboveRef);
 			if (!onGridForBelowRef.equals(onGridForAboveRef)) {
 				onVerticalGridLocs.add(onGridForBelowRef);
 			}
 		}
 		for (double nextX = gridX + notOnGrid.preciseX() - reminderX; nextX <= bounds
 				.preciseX() + bounds.preciseWidth(); nextX += gridX) {
 			fakeRefAbove.setPreciseX(nextX);
 			fakeRefBelow.setPreciseX(nextX);
 			Point onGridForAboveRef = getOrthogonalLocationNoSnap(fakeRefAbove);
 			Point onGridForBelowRef = getOrthogonalLocationNoSnap(fakeRefBelow);
 			onVerticalGridLocs.add(onGridForAboveRef);
 			if (!onGridForBelowRef.equals(onGridForAboveRef)) {
 				onVerticalGridLocs.add(onGridForBelowRef);
 			}
 		}

 		PrecisionPoint fakeRefLeft = new PrecisionPoint(notOnGrid);
 		PrecisionPoint fakeRefRight = new PrecisionPoint(notOnGrid);
 		fakeRefLeft.setPreciseX(bounds.preciseX() - bounds.preciseWidth() / 2);
 		fakeRefRight.setPreciseX(bounds.preciseX() + bounds.preciseWidth()
 				+ bounds.preciseWidth() / 2);
 		double reminderY = Math.IEEEremainder(
 				notOnGrid.preciseY() - gridOrigin.preciseY(), gridY);
 		if (reminderY < 0) {
 			reminderY += gridY;
 		}
 		for (double nextY = notOnGrid.preciseY() - reminderY; nextY >= bounds
 				.preciseY(); nextY -= gridY) {
 			fakeRefLeft.setPreciseY(nextY);
 			fakeRefRight.setPreciseY(nextY);
 			Point onGridForLeftRef = getOrthogonalLocationNoSnap(fakeRefLeft);
 			Point onGridForRightRef = getOrthogonalLocationNoSnap(fakeRefRight);
 			onHorizontalGridLocs.add(onGridForLeftRef);
 			if (!onGridForLeftRef.equals(onGridForRightRef)) {
 				onHorizontalGridLocs.add(onGridForRightRef);
 			}
 		}
 		for (double nextY = gridY + notOnGrid.preciseY() - reminderY; nextY <= bounds
 				.preciseY() + bounds.preciseHeight(); nextY += gridY) {
 			fakeRefLeft.setPreciseY(nextY);
 			fakeRefRight.setPreciseY(nextY);
 			Point onGridForLeftRef = getOrthogonalLocationNoSnap(fakeRefLeft);
 			Point onGridForRightRef = getOrthogonalLocationNoSnap(fakeRefRight);
 			onHorizontalGridLocs.add(onGridForLeftRef);
 			if (!onGridForLeftRef.equals(onGridForRightRef)) {
 				onHorizontalGridLocs.add(onGridForRightRef);
 			}
 		}

 		// System.err.println("Found: on horizontal grid: " +
 		// onHorizontalGridLocs);
 		// System.err.println("Found: on vertical grid: " + onVerticalGridLocs);
 	}

 	protected Point getOrthogonalLocationNoSnap(Point refPoint) {
 		return super.getOrthogonalLocation(refPoint);
 	}

 }
	/*****************************************************************************
	* Copyright (c) 2014-15 CEA LIST, Montages AG 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:
	* Michael Golubev (Montages) - Initial API and implementation
	*
	*****************************************************************************/
	package org.eclipse.gmf.tooling.runtime.linklf;

	import java.util.Collection;
	import java.util.LinkedList;
	import java.util.List;

	import org.eclipse.draw2d.PositionConstants;
	import org.eclipse.draw2d.geometry.Point;
	import org.eclipse.draw2d.geometry.PrecisionPoint;
	import org.eclipse.draw2d.geometry.PrecisionRectangle;
	import org.eclipse.draw2d.geometry.Rectangle;
	import org.eclipse.gef.EditPartViewer;
	import org.eclipse.gmf.runtime.draw2d.ui.figures.FigureUtilities;
	import org.eclipse.gmf.runtime.gef.ui.figures.NodeFigure;
	import org.eclipse.gmf.runtime.gef.ui.figures.SlidableAnchor;

	/**
	* Extends {@link SlidableAnchor} with ability to snap to the intersection
	* points between the host anchorable bounds and the active diagram grid.
	*
	* @since 3.3
	*/
	public class SlidableSnapToGridAnchor extends SlidableAnchor {

	private EditPartViewer myGridProvider;

	public SlidableSnapToGridAnchor(NodeFigure f, PrecisionPoint p) {
	super(f, p);
	}

	public void setEditPartViewer(EditPartViewer viewer) {
	myGridProvider = viewer;
	}

	@Override
	public Point getOrthogonalLocation(Point orthoReference) {
	Point result = getOrthogonalLocationNoSnap(orthoReference);
	if (result != null) {
	Rectangle gridSpecAbs = getAbsoluteGridSpec();
	LinkedList<Point> onVerticalGrid = new LinkedList<Point>();
	LinkedList<Point> onHorizontalGrid = new LinkedList<Point>();
	computeAnchorablePointsOnGrid(gridSpecAbs, onVerticalGrid,
	onHorizontalGrid);

	if (!onHorizontalGrid.isEmpty() \|\| !onVerticalGrid.isEmpty()) {
	return pickClosestPointToSet(result, onHorizontalGrid,
	onVerticalGrid);
	}
	}
	return result;
	}

	private boolean myGetLocationReentryLock = false;

	@Override
	public Point getLocation(Point reference) {
	Rectangle gridSpecAbs = getAbsoluteGridSpec();
	if (gridSpecAbs != null && !myGetLocationReentryLock) {
	myGetLocationReentryLock = true;
	try {
	List<Point> onVerticalGrid = new LinkedList<Point>();
	List<Point> onHorizontalGrid = new LinkedList<Point>();

	computeAnchorablePointsOnGrid(gridSpecAbs, onVerticalGrid,
	onHorizontalGrid);

	if (!onVerticalGrid.isEmpty() \|\| !onVerticalGrid.isEmpty()) {
	return pickClosestPointToSet(getReferencePoint(),
	onHorizontalGrid, onVerticalGrid);
	}
	} finally {
	myGetLocationReentryLock = false;
	}
	}

	Point result = super.getLocation(reference);
	return result;
	}

	/**
	* @see bug #451604, we don't want anchor to move even if the resulting line
	* is close to straight
	* <p/>
	* So we will block the normalization for instances of this class.
	*/
	@Override
	protected Point normalizeToStraightlineTolerance(Point foreignReference,
	Point ownReference, int tolerance) {
	final int NO_TOLERANCE = 0;
	return super.normalizeToStraightlineTolerance(foreignReference,
	ownReference, NO_TOLERANCE);
	}

	@Override
	public String toString() {
	return "SSTGA:" + "terminal: " + getTerminal() + ", terminalLoc: "
	+ getReferencePoint() + ", box: " + getBox();
	}

	/**
	* Returns the position of the closest edge of the rectangle closest to the
	* point
	*
	* @param p
	* the point
	* @param r
	* the rectangle
	* @return position of the closest edge
	* @deprecated copy-pasted from super class, [GMFRT] make protected
	*/
	@Deprecated
	public static int getClosestSide2(Point p, Rectangle r) {
	double diff = Math.abs(r.preciseX() + r.preciseWidth() - p.preciseX());
	int side = PositionConstants.RIGHT;
	double currentDiff = Math.abs(r.preciseX() - p.preciseX());
	if (currentDiff < diff) {
	diff = currentDiff;
	side = PositionConstants.LEFT;
	}
	currentDiff = Math.abs(r.preciseY() + r.preciseHeight() - p.preciseY());
	if (currentDiff < diff) {
	diff = currentDiff;
	side = PositionConstants.BOTTOM;
	}
	currentDiff = Math.abs(r.preciseY() - p.preciseY());
	if (currentDiff < diff) {
	diff = currentDiff;
	side = PositionConstants.TOP;
	}
	return side;
	}

	/**
	* If grid provider had been set up and has grid enabled then returns active
	* grid specification in absolute coordinates. Otherwise returns null.
	*
	* @return <code>null</code> if no active grid or grid provider had not been
	* set up.
	*/
	protected Rectangle getAbsoluteGridSpec() {
	return myGridProvider == null ? null : DiagramGridSpec
	.getAbsoluteGridSpec(myGridProvider);
	}

	protected static Point pickClosestPointToSet(Point source,
	Collection<? extends Point> set1, Collection<? extends Point> set2) {
	double bestDistSquared = Double.MAX_VALUE;
	Point result = null;
	for (Point next : set1) {
	double nextDistSquared = source.getDistance(next);
	if (nextDistSquared < bestDistSquared) {
	result = next;
	bestDistSquared = nextDistSquared;
	}
	}
	for (Point next : set2) {
	double nextDistSquared = source.getDistance(next);
	if (nextDistSquared < bestDistSquared) {
	result = next;
	bestDistSquared = nextDistSquared;
	}
	}
	return result;
	}

	/**
	* Computes possible anchorable points on grid for given gridSpec. Results
	* are pushed into the given lists, separately for points computed for
	* vertical and horizontal grid.
	* <p/>
	* As results of this method depends only on the owner location and the
	* gridspec, they may be cached to improve performance.
	*
	* @param gridSpecAbs
	* absolute grid specification, if <code>null</code> then method
	* does nothing
	* @param onVerticalGridLocs
	* output list to store points of vertical grid
	* @param onHorizontalGridLocs
	* output list to store points on horizontal grid
	*/
	protected void computeAnchorablePointsOnGrid(Rectangle gridSpecAbs,
	List<Point> onVerticalGridLocs, List<Point> onHorizontalGridLocs) {
	if (gridSpecAbs == null) {
	return;
	}
	double gridX = gridSpecAbs.preciseWidth();
	double gridY = gridSpecAbs.preciseWidth();
	Point gridOrigin = gridSpecAbs.getLocation();

	PrecisionRectangle bounds = new PrecisionRectangle(
	FigureUtilities.getAnchorableFigureBounds(getOwner()));
	getOwner().translateToAbsolute(bounds);

	Point notOnGrid = bounds.getCenter();

	PrecisionPoint fakeRefAbove = new PrecisionPoint(notOnGrid);
	PrecisionPoint fakeRefBelow = new PrecisionPoint(notOnGrid);
	fakeRefAbove
	.setPreciseY(bounds.preciseY() - bounds.preciseHeight() / 2);
	fakeRefBelow.setPreciseY(bounds.preciseY() + bounds.preciseHeight() / 2
	+ bounds.preciseHeight());

	double reminderX = Math.IEEEremainder(
	notOnGrid.preciseX() - gridOrigin.preciseX(), gridX);
	if (reminderX < 0) {
	reminderX += gridX;
	}
	for (double nextX = notOnGrid.preciseX() - reminderX; nextX >= bounds
	.preciseX(); nextX -= gridX) {
	fakeRefAbove.setPreciseX(nextX);
	fakeRefBelow.setPreciseX(nextX);
	Point onGridForAboveRef = getOrthogonalLocationNoSnap(fakeRefAbove);
	Point onGridForBelowRef = getOrthogonalLocationNoSnap(fakeRefBelow);
	onVerticalGridLocs.add(onGridForAboveRef);
	if (!onGridForBelowRef.equals(onGridForAboveRef)) {
	onVerticalGridLocs.add(onGridForBelowRef);
	}
	}
	for (double nextX = gridX + notOnGrid.preciseX() - reminderX; nextX <= bounds
	.preciseX() + bounds.preciseWidth(); nextX += gridX) {
	fakeRefAbove.setPreciseX(nextX);
	fakeRefBelow.setPreciseX(nextX);
	Point onGridForAboveRef = getOrthogonalLocationNoSnap(fakeRefAbove);
	Point onGridForBelowRef = getOrthogonalLocationNoSnap(fakeRefBelow);
	onVerticalGridLocs.add(onGridForAboveRef);
	if (!onGridForBelowRef.equals(onGridForAboveRef)) {
	onVerticalGridLocs.add(onGridForBelowRef);
	}
	}

	PrecisionPoint fakeRefLeft = new PrecisionPoint(notOnGrid);
	PrecisionPoint fakeRefRight = new PrecisionPoint(notOnGrid);
	fakeRefLeft.setPreciseX(bounds.preciseX() - bounds.preciseWidth() / 2);
	fakeRefRight.setPreciseX(bounds.preciseX() + bounds.preciseWidth()
	+ bounds.preciseWidth() / 2);
	double reminderY = Math.IEEEremainder(
	notOnGrid.preciseY() - gridOrigin.preciseY(), gridY);
	if (reminderY < 0) {
	reminderY += gridY;
	}
	for (double nextY = notOnGrid.preciseY() - reminderY; nextY >= bounds
	.preciseY(); nextY -= gridY) {
	fakeRefLeft.setPreciseY(nextY);
	fakeRefRight.setPreciseY(nextY);
	Point onGridForLeftRef = getOrthogonalLocationNoSnap(fakeRefLeft);
	Point onGridForRightRef = getOrthogonalLocationNoSnap(fakeRefRight);
	onHorizontalGridLocs.add(onGridForLeftRef);
	if (!onGridForLeftRef.equals(onGridForRightRef)) {
	onHorizontalGridLocs.add(onGridForRightRef);
	}
	}
	for (double nextY = gridY + notOnGrid.preciseY() - reminderY; nextY <= bounds
	.preciseY() + bounds.preciseHeight(); nextY += gridY) {
	fakeRefLeft.setPreciseY(nextY);
	fakeRefRight.setPreciseY(nextY);
	Point onGridForLeftRef = getOrthogonalLocationNoSnap(fakeRefLeft);
	Point onGridForRightRef = getOrthogonalLocationNoSnap(fakeRefRight);
	onHorizontalGridLocs.add(onGridForLeftRef);
	if (!onGridForLeftRef.equals(onGridForRightRef)) {
	onHorizontalGridLocs.add(onGridForRightRef);
	}
	}

	// System.err.println("Found: on horizontal grid: " +
	// onHorizontalGridLocs);
	// System.err.println("Found: on vertical grid: " + onVerticalGridLocs);
	}

	protected Point getOrthogonalLocationNoSnap(Point refPoint) {
	return super.getOrthogonalLocation(refPoint);
	}

	}