plugins/org.eclipse.graphiti.ui/src/org/eclipse/graphiti/ui/internal/figures/FlexibleRotatableLocator.java - graphiti/org.eclipse.graphiti - Git at Google

 /*******************************************************************************
  * <copyright>
  *
  * Copyright (c) 2005, 2012 SAP AG.
  * 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:
  *    SAP AG - initial API, implementation and documentation
  *    mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
  *    mgorning - Bug 368124 - ConnectionDecorator with Text causes problems
  *
  * </copyright>
  *
  *******************************************************************************/
 package org.eclipse.graphiti.ui.internal.figures;

 import org.eclipse.draw2d.AbstractLocator;
 import org.eclipse.draw2d.Connection;
 import org.eclipse.draw2d.IFigure;
 import org.eclipse.draw2d.RotatableDecoration;
 import org.eclipse.draw2d.geometry.Point;
 import org.eclipse.draw2d.geometry.PointList;
 import org.eclipse.draw2d.geometry.PrecisionPoint;
 import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;

 /**
  * This is a very flexible Locator, which places a {@link RotatableDecoration}
  * or a non-rotatable IFigure on a {@link Connection}. The location is
  * determined using a relative distance on the connection (e.g. "0.5" is the
  * middle of the connection) and/or using an absolute distance on the connection
  * (e.g. "100" is 100 pixel from the anchor).
  *
  * @noinstantiate This class is not intended to be instantiated by clients.
  * @noextend This class is not intended to be subclassed by clients.
  */
 public class FlexibleRotatableLocator extends AbstractLocator {

 	/**
 	 * A small data-structure, which contains the important results of the
 	 * calculated location.
 	 */
 	private class CalculationResult {
 		/**
 		 * The calculated location on the connection.
 		 */
 		private Point location;

 		/**
 		 * The start-point of the line-segment of the connection, in which the
 		 * location is placed. It is needed to calculate the angle of the line
 		 * through the location.
 		 */
 		private Point segmentStart;

 		/**
 		 * The end-point of the line-segment of the connection, in which the
 		 * location is placed. It is needed to calculate the angle of the line
 		 * through the location.
 		 */
 		private Point segmentEnd;
 	}

 	/**
 	 * The connection, as described in {@link #getConnection()}.
 	 */
 	private Connection connection;

 	/**
 	 * If the distance values refer to the start-point or the end-point. See
 	 * {@link #getDistanceToStart()}.
 	 */
 	private boolean distanceToStart;

 	/**
 	 * The relative distance, as described in {@link #getRelativeDistance()}.
 	 */
 	private double relativeDistance;

 	/**
 	 * The absolute distance, as described in {@link #getAbsoluteDistance()}.
 	 */
 	private int absoluteDistance;

 	/**
 	 * The degrees to rotate, as described in {@link #getRotateDegrees()}.
 	 */
 	private double rotateDegrees;

 	/**
 	 * Creates a new FlexibleRotabableLocator.
 	 *
 	 * @param connection
 	 *            The connection, as described in {@link #getConnection()}.
 	 * @param distanceToStart
 	 *            If the distance values refer to the start-point or the
 	 *            end-point. See {@link #getDistanceToStart()}.
 	 * @param relativeDistance
 	 *            The relative distance, as described in
 	 *            {@link #getRelativeDistance()}.
 	 * @param absoluteDistance
 	 *            The absolute distance, as described in
 	 *            {@link #getAbsoluteDistance()}.
 	 * @param rotateDegrees
 	 *            The degrees to rotate, as described in
 	 *            {@link #getRotateDegrees()}.
 	 */
 	public FlexibleRotatableLocator(Connection connection, boolean distanceToStart, double relativeDistance,
 			int absoluteDistance, double rotateDegrees) {
 		assert (connection != null);
 		this.connection = connection;
 		setDistanceToStart(distanceToStart);
 		setRelativeDistance(relativeDistance);
 		setAbsoluteDistance(absoluteDistance);
 		setRotateDegrees(rotateDegrees);
 	}

 	/**
 	 * Returns the connection, on which this Locator places the location.
 	 *
 	 * @return The connection, on which this Locator places the location.
 	 */
 	protected final Connection getConnection() {
 		return connection;
 	}

 	/**
 	 * Returns true, if the distance values (see {@link #getRelativeDistance()}
 	 * and {@link #getAbsoluteDistance()}) refer to the start point of the
 	 * connection. Returns false, if the distance values refer to the end point
 	 * of the connection. For example if a relative and absolute distance are
 	 * "0", then returning true will place the location on the start point and
 	 * returning false on the end point.
 	 *
 	 * @return If the distance values refer to the start-point or the end-point.
 	 */
 	public final boolean getDistanceToStart() {
 		return distanceToStart;
 	}

 	/**
 	 * Sets, If the distance values refer to the start-point or the end-point.
 	 * For details see {@link #getDistanceToStart()}.
 	 *
 	 * @param distanceToStart
 	 *            If true, the distance values refer to the start-point.
 	 */
 	public final void setDistanceToStart(boolean distanceToStart) {
 		this.distanceToStart = distanceToStart;
 	}

 	/**
 	 * Returns the relative distance of the location to the start/end-point. The
 	 * total distance is calculated by ([relative distance] * [length of
 	 * connection] + [absolute distance]).
 	 *
 	 * @return The relative distance of the location to the start/end-point.
 	 * @see #getAbsoluteDistance()
 	 * @see #getDistanceToStart()
 	 */
 	public final double getRelativeDistance() {
 		return relativeDistance;
 	}

 	/**
 	 * Sets the relative distance of the location to the start/end-point. For
 	 * details see {@link #getRelativeDistance()}.
 	 *
 	 * @param relativeDistance
 	 *            The relative distance of the location to the start/end-point.
 	 */
 	public final void setRelativeDistance(double relativeDistance) {
 		this.relativeDistance = relativeDistance;
 	}

 	/**
 	 * Returns the absolute distance of the location to the start/end-point. The
 	 * total distance is calculated by ([relative distance] * [length of
 	 * connection] + [absolute distance]).
 	 *
 	 * @return The absolute distance of the location to the start/end-point.
 	 * @see #getRelativeDistance()
 	 * @see #getDistanceToStart()
 	 */
 	public final int getAbsoluteDistance() {
 		return absoluteDistance;
 	}

 	/**
 	 * Sets the absolute distance of the location to the start/end-point. For
 	 * details see {@link #getAbsoluteDistance()}.
 	 *
 	 * @param absoluteDistance
 	 *            The absolute distance of the location to the start/end-point.
 	 */
 	public final void setAbsoluteDistance(int absoluteDistance) {
 		this.absoluteDistance = absoluteDistance;
 	}

 	/**
 	 * Returns the degrees, around which the figure shall be rotated, if it is a
 	 * RotatableDecoration. This rotation around a fixed value is done
 	 * additionally to the dynamic rotation depending on the connection.
 	 *
 	 * @return The degrees, around which the figure shall be rotated, if it is a
 	 *         RotatableDecoration.
 	 */
 	public final double getRotateDegrees() {
 		return rotateDegrees;
 	}

 	/**
 	 * Sets the degrees, around which the figure shall be rotated, if it is a
 	 * RotatableDecoration. For details see {@link #getRotateDegrees()}.
 	 *
 	 * @param rotateDegrees
 	 *            The degrees, around which the figure shall be rotated, if it
 	 *            is a RotatableDecoration.
 	 */
 	public final void setRotateDegrees(double rotateDegrees) {
 		this.rotateDegrees = rotateDegrees;
 	}

 	/**
 	 * Calculates the location based on the current distance values and the
 	 * connection.
 	 *
 	 * @return The location based on the current distance values and the
 	 *         connection.
 	 */
 	protected CalculationResult calculateLocation() {
 		PointList pointList = getConnection().getPoints();
 		assert (pointList.size() >= 2); // all connections must have start point
 		// and end point

 		CalculationResult result = new CalculationResult();

 		// sort the points of the connection (start to end / end to start)
 		Point allPoints[] = new Point[pointList.size()];
 		for (int i = 0; i < allPoints.length; i++) {
 			if (getDistanceToStart()) {
 				allPoints[i] = pointList.getPoint(i);
 			} else {
 				allPoints[(allPoints.length - 1) - i] = pointList.getPoint(i);
 			}
 		}

 		// quick check for improved performance
 		if (getAbsoluteDistance() == 0 && getRelativeDistance() == 0) {
 			result.segmentStart = allPoints[0];
 			result.segmentEnd = allPoints[1];
 			result.location = result.segmentStart;
 			return result;
 		}
 		if (getAbsoluteDistance() == 0 && getRelativeDistance() == 1) {
 			result.segmentStart = allPoints[allPoints.length - 2];
 			result.segmentEnd = allPoints[allPoints.length - 1];
 			result.location = result.segmentEnd;
 			return result;
 		}

 		// calculate the total length of the connection and of each connection
 		// segment
 		double totalLength = 0;
 		double segmentLength[] = new double[allPoints.length - 1];
 		for (int i = 0; i < segmentLength.length; i++) {
 			segmentLength[i] = allPoints[i].getDistance(allPoints[i + 1]);
 			totalLength += segmentLength[i];
 		}

 		// determine total distance
 		double totalDistance = totalLength * getRelativeDistance() + getAbsoluteDistance();

 		// determine the target segment
 		int targetIndex = 0;
 		double lengthBeforeTargetSegment = 0;
 		for (targetIndex = 0; targetIndex < segmentLength.length - 1; targetIndex++) {
 			if (lengthBeforeTargetSegment + segmentLength[targetIndex] < totalDistance) {
 				lengthBeforeTargetSegment += segmentLength[targetIndex];
 			} else {
 				break;
 			}
 		}
 		result.segmentStart = allPoints[targetIndex];
 		result.segmentEnd = allPoints[targetIndex + 1];

 		// determine location in target segment
 		if (segmentLength[targetIndex] == 0) { // both points of segment are
 			// identical (avoid division by
 			// zero)
 			result.location = result.segmentStart;
 		} else {
 			double absoluteDistanceInSegment = totalDistance - lengthBeforeTargetSegment;
 			double relativeDistanceInSegment = absoluteDistanceInSegment / segmentLength[targetIndex];
 			double locationX = result.segmentStart.x
 					+ ((result.segmentEnd.x - result.segmentStart.x) * relativeDistanceInSegment);
 			double locationY = result.segmentStart.y
 					+ ((result.segmentEnd.y - result.segmentStart.y) * relativeDistanceInSegment);
 			result.location = new PrecisionPoint(locationX, locationY);
 		}

 		return result;
 	}

 	/**
 	 * Returns the location on the connection, which is calculated based on the
 	 * current distance values and the connection.
 	 *
 	 * @return The location on the connection.
 	 */
 	@Override
 	protected Point getReferencePoint() {
 		CalculationResult calculationResult = calculateLocation();
 		getConnection().translateToAbsolute(calculationResult.location);
 		return calculationResult.location;
 	}

 	/**
 	 * Rotates the figure, if it is a RotatableDecoration.
 	 *
 	 * @param target
 	 *            The figure to rotate.
 	 */
 	@Override
 	public void relocate(IFigure target) {
 		if (target instanceof RotatableDecoration) {
 			CalculationResult calculationResult = calculateLocation();
 			RotatableDecoration rotatable = (RotatableDecoration) target;
 			if (rotatable instanceof GFText) {
 				GFText text = (GFText) rotatable;
 				GraphicsAlgorithm ga = text.getGraphicsAlgorithm();
 				Point textLocation = calculationResult.location.getCopy().translate(ga.getX(), ga.getY());
 				rotatable.setLocation(textLocation);
 			} else {
 				rotatable.setLocation(calculationResult.location);
 			}

 			// determine reference point
 			Point p1 = calculationResult.segmentStart;
 			Point p2 = calculationResult.segmentEnd;
 			Point reference;
 			if (p1.equals(p2)) { // no clear direction -> choose "horizontal"
 				reference = calculationResult.location.getCopy().translate(-10, 0);
 			} else { // extend line through [p1, p2] to keep direction
 				reference = new Point();
 				reference.x = p2.x + (p2.x - p1.x);
 				reference.y = p2.y + (p2.y - p1.y);

 				rotatePoint(calculationResult.location, reference, getRotateDegrees());
 			}
 			rotatable.setReferencePoint(reference);
 		} else {
 			super.relocate(target);
 		}
 	}

 	protected void rotatePoint(Point center, Point rotate, double degrees) {
 		if (degrees != 0) {
 			double radians = Math.toRadians(degrees);
 			double sin = Math.sin(radians);
 			double cos = Math.cos(radians);

 			Point v = new Point(rotate.x - center.x, rotate.y - center.y);

 			rotate.x = center.x + (int) (cos * v.x - sin * v.y);
 			rotate.y = center.y + (int) (sin * v.x + cos * v.y);
 		}
 	}
 }
	/*******************************************************************************
	* <copyright>
	*
	* Copyright (c) 2005, 2012 SAP AG.
	* 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:
	* SAP AG - initial API, implementation and documentation
	* mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
	* mgorning - Bug 368124 - ConnectionDecorator with Text causes problems
	*
	* </copyright>
	*
	*******************************************************************************/
	package org.eclipse.graphiti.ui.internal.figures;

	import org.eclipse.draw2d.AbstractLocator;
	import org.eclipse.draw2d.Connection;
	import org.eclipse.draw2d.IFigure;
	import org.eclipse.draw2d.RotatableDecoration;
	import org.eclipse.draw2d.geometry.Point;
	import org.eclipse.draw2d.geometry.PointList;
	import org.eclipse.draw2d.geometry.PrecisionPoint;
	import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;

	/**
	* This is a very flexible Locator, which places a {@link RotatableDecoration}
	* or a non-rotatable IFigure on a {@link Connection}. The location is
	* determined using a relative distance on the connection (e.g. "0.5" is the
	* middle of the connection) and/or using an absolute distance on the connection
	* (e.g. "100" is 100 pixel from the anchor).
	*
	* @noinstantiate This class is not intended to be instantiated by clients.
	* @noextend This class is not intended to be subclassed by clients.
	*/
	public class FlexibleRotatableLocator extends AbstractLocator {

	/**
	* A small data-structure, which contains the important results of the
	* calculated location.
	*/
	private class CalculationResult {
	/**
	* The calculated location on the connection.
	*/
	private Point location;

	/**
	* The start-point of the line-segment of the connection, in which the
	* location is placed. It is needed to calculate the angle of the line
	* through the location.
	*/
	private Point segmentStart;

	/**
	* The end-point of the line-segment of the connection, in which the
	* location is placed. It is needed to calculate the angle of the line
	* through the location.
	*/
	private Point segmentEnd;
	}

	/**
	* The connection, as described in {@link #getConnection()}.
	*/
	private Connection connection;

	/**
	* If the distance values refer to the start-point or the end-point. See
	* {@link #getDistanceToStart()}.
	*/
	private boolean distanceToStart;

	/**
	* The relative distance, as described in {@link #getRelativeDistance()}.
	*/
	private double relativeDistance;

	/**
	* The absolute distance, as described in {@link #getAbsoluteDistance()}.
	*/
	private int absoluteDistance;

	/**
	* The degrees to rotate, as described in {@link #getRotateDegrees()}.
	*/
	private double rotateDegrees;

	/**
	* Creates a new FlexibleRotabableLocator.
	*
	* @param connection
	* The connection, as described in {@link #getConnection()}.
	* @param distanceToStart
	* If the distance values refer to the start-point or the
	* end-point. See {@link #getDistanceToStart()}.
	* @param relativeDistance
	* The relative distance, as described in
	* {@link #getRelativeDistance()}.
	* @param absoluteDistance
	* The absolute distance, as described in
	* {@link #getAbsoluteDistance()}.
	* @param rotateDegrees
	* The degrees to rotate, as described in
	* {@link #getRotateDegrees()}.
	*/
	public FlexibleRotatableLocator(Connection connection, boolean distanceToStart, double relativeDistance,
	int absoluteDistance, double rotateDegrees) {
	assert (connection != null);
	this.connection = connection;
	setDistanceToStart(distanceToStart);
	setRelativeDistance(relativeDistance);
	setAbsoluteDistance(absoluteDistance);
	setRotateDegrees(rotateDegrees);
	}

	/**
	* Returns the connection, on which this Locator places the location.
	*
	* @return The connection, on which this Locator places the location.
	*/
	protected final Connection getConnection() {
	return connection;
	}

	/**
	* Returns true, if the distance values (see {@link #getRelativeDistance()}
	* and {@link #getAbsoluteDistance()}) refer to the start point of the
	* connection. Returns false, if the distance values refer to the end point
	* of the connection. For example if a relative and absolute distance are
	* "0", then returning true will place the location on the start point and
	* returning false on the end point.
	*
	* @return If the distance values refer to the start-point or the end-point.
	*/
	public final boolean getDistanceToStart() {
	return distanceToStart;
	}

	/**
	* Sets, If the distance values refer to the start-point or the end-point.
	* For details see {@link #getDistanceToStart()}.
	*
	* @param distanceToStart
	* If true, the distance values refer to the start-point.
	*/
	public final void setDistanceToStart(boolean distanceToStart) {
	this.distanceToStart = distanceToStart;
	}

	/**
	* Returns the relative distance of the location to the start/end-point. The
	* total distance is calculated by ([relative distance] * [length of
	* connection] + [absolute distance]).
	*
	* @return The relative distance of the location to the start/end-point.
	* @see #getAbsoluteDistance()
	* @see #getDistanceToStart()
	*/
	public final double getRelativeDistance() {
	return relativeDistance;
	}

	/**
	* Sets the relative distance of the location to the start/end-point. For
	* details see {@link #getRelativeDistance()}.
	*
	* @param relativeDistance
	* The relative distance of the location to the start/end-point.
	*/
	public final void setRelativeDistance(double relativeDistance) {
	this.relativeDistance = relativeDistance;
	}

	/**
	* Returns the absolute distance of the location to the start/end-point. The
	* total distance is calculated by ([relative distance] * [length of
	* connection] + [absolute distance]).
	*
	* @return The absolute distance of the location to the start/end-point.
	* @see #getRelativeDistance()
	* @see #getDistanceToStart()
	*/
	public final int getAbsoluteDistance() {
	return absoluteDistance;
	}

	/**
	* Sets the absolute distance of the location to the start/end-point. For
	* details see {@link #getAbsoluteDistance()}.
	*
	* @param absoluteDistance
	* The absolute distance of the location to the start/end-point.
	*/
	public final void setAbsoluteDistance(int absoluteDistance) {
	this.absoluteDistance = absoluteDistance;
	}

	/**
	* Returns the degrees, around which the figure shall be rotated, if it is a
	* RotatableDecoration. This rotation around a fixed value is done
	* additionally to the dynamic rotation depending on the connection.
	*
	* @return The degrees, around which the figure shall be rotated, if it is a
	* RotatableDecoration.
	*/
	public final double getRotateDegrees() {
	return rotateDegrees;
	}

	/**
	* Sets the degrees, around which the figure shall be rotated, if it is a
	* RotatableDecoration. For details see {@link #getRotateDegrees()}.
	*
	* @param rotateDegrees
	* The degrees, around which the figure shall be rotated, if it
	* is a RotatableDecoration.
	*/
	public final void setRotateDegrees(double rotateDegrees) {
	this.rotateDegrees = rotateDegrees;
	}

	/**
	* Calculates the location based on the current distance values and the
	* connection.
	*
	* @return The location based on the current distance values and the
	* connection.
	*/
	protected CalculationResult calculateLocation() {
	PointList pointList = getConnection().getPoints();
	assert (pointList.size() >= 2); // all connections must have start point
	// and end point

	CalculationResult result = new CalculationResult();

	// sort the points of the connection (start to end / end to start)
	Point allPoints[] = new Point[pointList.size()];
	for (int i = 0; i < allPoints.length; i++) {
	if (getDistanceToStart()) {
	allPoints[i] = pointList.getPoint(i);
	} else {
	allPoints[(allPoints.length - 1) - i] = pointList.getPoint(i);
	}
	}

	// quick check for improved performance
	if (getAbsoluteDistance() == 0 && getRelativeDistance() == 0) {
	result.segmentStart = allPoints[0];
	result.segmentEnd = allPoints[1];
	result.location = result.segmentStart;
	return result;
	}
	if (getAbsoluteDistance() == 0 && getRelativeDistance() == 1) {
	result.segmentStart = allPoints[allPoints.length - 2];
	result.segmentEnd = allPoints[allPoints.length - 1];
	result.location = result.segmentEnd;
	return result;
	}

	// calculate the total length of the connection and of each connection
	// segment
	double totalLength = 0;
	double segmentLength[] = new double[allPoints.length - 1];
	for (int i = 0; i < segmentLength.length; i++) {
	segmentLength[i] = allPoints[i].getDistance(allPoints[i + 1]);
	totalLength += segmentLength[i];
	}

	// determine total distance
	double totalDistance = totalLength * getRelativeDistance() + getAbsoluteDistance();

	// determine the target segment
	int targetIndex = 0;
	double lengthBeforeTargetSegment = 0;
	for (targetIndex = 0; targetIndex < segmentLength.length - 1; targetIndex++) {
	if (lengthBeforeTargetSegment + segmentLength[targetIndex] < totalDistance) {
	lengthBeforeTargetSegment += segmentLength[targetIndex];
	} else {
	break;
	}
	}
	result.segmentStart = allPoints[targetIndex];
	result.segmentEnd = allPoints[targetIndex + 1];

	// determine location in target segment
	if (segmentLength[targetIndex] == 0) { // both points of segment are
	// identical (avoid division by
	// zero)
	result.location = result.segmentStart;
	} else {
	double absoluteDistanceInSegment = totalDistance - lengthBeforeTargetSegment;
	double relativeDistanceInSegment = absoluteDistanceInSegment / segmentLength[targetIndex];
	double locationX = result.segmentStart.x
	+ ((result.segmentEnd.x - result.segmentStart.x) * relativeDistanceInSegment);
	double locationY = result.segmentStart.y
	+ ((result.segmentEnd.y - result.segmentStart.y) * relativeDistanceInSegment);
	result.location = new PrecisionPoint(locationX, locationY);
	}

	return result;
	}

	/**
	* Returns the location on the connection, which is calculated based on the
	* current distance values and the connection.
	*
	* @return The location on the connection.
	*/
	@Override
	protected Point getReferencePoint() {
	CalculationResult calculationResult = calculateLocation();
	getConnection().translateToAbsolute(calculationResult.location);
	return calculationResult.location;
	}

	/**
	* Rotates the figure, if it is a RotatableDecoration.
	*
	* @param target
	* The figure to rotate.
	*/
	@Override
	public void relocate(IFigure target) {
	if (target instanceof RotatableDecoration) {
	CalculationResult calculationResult = calculateLocation();
	RotatableDecoration rotatable = (RotatableDecoration) target;
	if (rotatable instanceof GFText) {
	GFText text = (GFText) rotatable;
	GraphicsAlgorithm ga = text.getGraphicsAlgorithm();
	Point textLocation = calculationResult.location.getCopy().translate(ga.getX(), ga.getY());
	rotatable.setLocation(textLocation);
	} else {
	rotatable.setLocation(calculationResult.location);
	}

	// determine reference point
	Point p1 = calculationResult.segmentStart;
	Point p2 = calculationResult.segmentEnd;
	Point reference;
	if (p1.equals(p2)) { // no clear direction -> choose "horizontal"
	reference = calculationResult.location.getCopy().translate(-10, 0);
	} else { // extend line through [p1, p2] to keep direction
	reference = new Point();
	reference.x = p2.x + (p2.x - p1.x);
	reference.y = p2.y + (p2.y - p1.y);

	rotatePoint(calculationResult.location, reference, getRotateDegrees());
	}
	rotatable.setReferencePoint(reference);
	} else {
	super.relocate(target);
	}
	}

	protected void rotatePoint(Point center, Point rotate, double degrees) {
	if (degrees != 0) {
	double radians = Math.toRadians(degrees);
	double sin = Math.sin(radians);
	double cos = Math.cos(radians);

	Point v = new Point(rotate.x - center.x, rotate.y - center.y);

	rotate.x = center.x + (int) (cos * v.x - sin * v.y);
	rotate.y = center.y + (int) (sin * v.x + cos * v.y);
	}
	}
	}