org.eclipse.gmf.runtime.diagram.ui/src/org/eclipse/gmf/runtime/diagram/ui/internal/figures/LabelHelper.java - gmf-runtime/org.eclipse.gmf-runtime - Git at Google

 /******************************************************************************
  * Copyright (c) 2005, 2009 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
  ****************************************************************************/
 package org.eclipse.gmf.runtime.diagram.ui.internal.figures;

 import org.eclipse.draw2d.Connection;
 import org.eclipse.draw2d.IFigure;
 import org.eclipse.draw2d.geometry.Point;
 import org.eclipse.draw2d.geometry.PointList;
 import org.eclipse.draw2d.geometry.Rectangle;

 import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg;
 import org.eclipse.gmf.runtime.draw2d.ui.geometry.PointListUtilities;

 /**
  * Helper class to convert the label coordinates from an offset value
  * from a keypoint to real draw2d coordinate
  *
  * @author sshaw
  *
  */
 public class LabelHelper {

 	/**
 	 * Calculates the label offset from the reference point given the label bounds.
 	 *
 	 * @param label the <code>IFigure</code> to calculate the offset for
 	 * @param bounds the <code>Rectangle</code> that is the bounding box of the label.
 	 * @param ref the <code>Point</code> that is the reference point that the offset
 	 * is based on.
 	 * @return a <code>Point</code> which represents a value offset from the <code>ref</code>
 	 * point oriented based on the nearest line segment.
 	 */
 	static public Point offsetFromRelativeCoordinate(IFigure label, Rectangle bounds, Point ref) {
 		return offsetFromRelativeCoordinate(label, bounds, getParentPointList(label), ref);
 	}

 	/**
 	 * Calculates the label offset from the reference point given the label bounds and a points list.
 	 *
 	 * @param label the <code>IFigure</code> to calculate the offset for
 	 * @param bounds the <code>Rectangle</code> that is the bounding box of the label.
 	 * @param points the <code>PointList</code> that contains that the label offset is relative to.
 	 * @param ref the <code>Point</code> that is the reference point that the offset
 	 * is based on.
 	 * @return a <code>Point</code> which represents a value offset from the <code>ref</code>
 	 * point oriented based on the nearest line segment.
 	 */
 	static private Point offsetFromRelativeCoordinate(IFigure label, Rectangle bounds, PointList points, Point ref) {
 		Rectangle rect = new Rectangle(bounds);

 		//Componsate for the fact that we are using the
 		// figure center
 		rect.translate(rect.width /2, rect.height /2);

 		Point normalPoint = normalizeRelativePointToPointOnLine(points, ref,
 				new Point(rect.x - ref.x, rect.y - ref.y));

 		return normalPoint;
 	}

 	/**
 	 * Calculates the relative coordinate that is equivalent to the offset from the reference
 	 * point, that can be used to set the label location.
 	 *
 	 * @param label the <code>IFigure</code> to calculate the relative coordinate for
 	 * @param ref a <code>Point</code> located on the parent which the offset value
 	 * is relative to.
 	 * @param offset a <code>Point</code> which represents a value offset from the <code>ref</code>
 	 * point oriented based on the nearest line segment.
 	 * @return a <code>Point</code> that is the relative coordinate of the label that can be
 	 * used to set it's location.
 	 */
 	static public Point relativeCoordinateFromOffset(IFigure label, Point ref, Point offset) {
 		return relativeCoordinateFromOffset(label, getParentPointList(label), ref, offset);
 	}

 	/**
 	 * Calculates the relative coordinate that is equivalent to the offset from the reference
 	 * point, that can be used to set the label location.
 	 *
 	 * @param label the <code>IFigure</code> to calculate the relative coordinate for
 	 * @param points the <code>PointList</code> that contains that the label offset is relative to.
 	 * @param ref a <code>Point</code> located on the parent which the offset value
 	 * is relative to.
 	 * @param offset a <code>Point</code> which represents a value offset from the <code>ref</code>
 	 * point oriented based on the nearest line segment.
 	 * @return a <code>Point</code> that is the relative coordinate of the label that can be
 	 * used to set it's location.
 	 */
 	static private Point relativeCoordinateFromOffset(IFigure label, PointList points, Point ref, Point offset) {
 		Point location = calculatePointRelativeToPointOnLine(points, ref, offset);
 		location.translate(-1 * label.getBounds().width /2, -1 * label.getBounds().height /2);
 		return location;
 	}

 	/**
 	 * gets the point list using the passed figure to get the parent
 	 *
 	 * @param label the <code>IFigure</code> to use to retrieve the parent points
 	 * @return List of points
 	 */
 	static private PointList getParentPointList(IFigure label) {
 		IFigure parent = label.getParent();
 		if (parent instanceof Connection) {
 			return ((Connection) parent).getPoints();
 		} else {
 			PointList ptList = new PointList();
 			ptList.addPoint(parent.getBounds().getLocation());
 			return ptList;
 		}
 	}

 	/**
 	 * Returns a point located relative to the line by the given offset.
 	 *
 	 * @param ptLst the point
 	 * @param ptOnLine
 	 * @param offset
 	 * @return the relative point given the line angle
 	 */
 	protected static Point calculatePointRelativeToPointOnLine(PointList ptLst, Point ptOnLine, Point offset) {
 		// Calculate slope of line
 		if (ptLst.size() == 1) {
 			// This is a node...
 			return ptLst.getFirstPoint().getTranslated(offset);
 		} else if (ptLst.size() >= 2){
 			// This is a edge...
 			int index = PointListUtilities.findNearestLineSegIndexOfPoint(ptLst, ptOnLine);
 			if (index < 1) {
 				return ptLst.getFirstPoint().getTranslated(offset);
 			}
 			LineSeg segment = (LineSeg) PointListUtilities.getLineSegments(ptLst).get(index - 1);
 			Point relativeOffset = null;
 			if (segment != null) {
 				if (segment.isHorizontal()) {
 					if (segment.getOrigin().x > segment.getTerminus().x) {
 						relativeOffset = ptOnLine.getTranslated(offset.getNegated());
 						//System.out.println("1. Relative offset: " + relativeOffset);//$NON-NLS-1$
 						return relativeOffset;
 					} else {
 						relativeOffset = ptOnLine.getTranslated(offset);
 						//System.out.println("2. Relative offset: " + relativeOffset);//$NON-NLS-1$
 						return relativeOffset;
 					}
 				} else if (segment.isVertical()) {
 					if (segment.getOrigin().y > segment.getTerminus().y) {
 						relativeOffset = ptOnLine.getTranslated(offset.getCopy().scale(-1, 1).transpose());
 						//System.out.println("3. Relative offset: " + relativeOffset);//$NON-NLS-1$
 						return relativeOffset;
 					} else {
 						relativeOffset = ptOnLine.getTranslated(offset.getCopy().scale(1, -1).transpose());
 						//System.out.println("4. Relative offset: " + relativeOffset);//$NON-NLS-1$
 						return relativeOffset;
 					}
 				} else {
 					double slope = segment.slope();
 					double theta = Math.atan(slope);
 					Point normalizedOffset = new Point(offset);
 					Point calculatedOffset = new Point();
 					if (segment.getOrigin().x > segment.getTerminus().x) {
 						normalizedOffset = offset.getCopy().scale(-1, -1);
 					}

 					calculatedOffset = new Point(normalizedOffset.x
 						* Math.cos(theta) - normalizedOffset.y
 						* Math.sin(theta), normalizedOffset.x * Math.sin(theta)
 						+ normalizedOffset.y * Math.cos(theta));
 					relativeOffset = ptOnLine.getTranslated(calculatedOffset);
 					//System.out.println("5. Relative offset: " + relativeOffset);//$NON-NLS-1$
 					return relativeOffset;
 				}
 			}
 		}
 		return null;
 	}

 	/**
 	 * Calculates the normalized offset from a point on a <code>Connection</code>'s point list to an point.
 	 *
 	 * @param ptLst
 	 * @param ptOnLine
 	 * @param offset
 	 * @return the normalized offset
 	 */
 	private static Point normalizeRelativePointToPointOnLine(PointList ptLst, Point ptOnLine, Point offset) {
 		// Calculate slope of line
 		if (ptLst.size() == 1) {
 			// This is a node...
 			return offset;
 		} else if (ptLst.size() >= 2){
 			// This is a edge...
 			int index = PointListUtilities.findNearestLineSegIndexOfPoint(ptLst, ptOnLine);
 			LineSeg segment = (LineSeg) PointListUtilities.getLineSegments(ptLst).get(index - 1);
 			Point normalOffset = null;
 			if (segment != null) {
 				if (segment.isHorizontal()) {
 					if (segment.getOrigin().x > segment.getTerminus().x) {
 						normalOffset = offset.getNegated();
 						//System.out.println("1. Normal offset: " + normalOffset);//$NON-NLS-1$
 						return normalOffset;
 					} else {
 						normalOffset = offset;
 						//System.out.println("2. Normal offset: " + normalOffset);//$NON-NLS-1$
 						return normalOffset;
 					}
 				} else if (segment.isVertical()) {
 					if (segment.getOrigin().y < segment.getTerminus().y) {
 						normalOffset = offset.scale(-1, 1).transpose();
 						//System.out.println("3. Normal offset: " + normalOffset);//$NON-NLS-1$
 						return normalOffset;
 					} else {
 						normalOffset = offset.scale(1, -1).transpose();
 						//System.out.println("4. Normal offset: " + normalOffset);//$NON-NLS-1$
 						return normalOffset;
 					}
 				} else {
 					Point p = ptOnLine.getTranslated(offset);
 					normalOffset = getOrthogonalDistances(segment, ptOnLine, p);
 					//System.out.println("5. Normal offset: " + normalOffset);//$NON-NLS-1$
 					return normalOffset;
 				}
 			}
 		}
 		return null;

 	}

 	/**
 	 * Calculates distances from a <code>Point</code> on a <code>LineSeg</code> to
 	 * another <code>Point</code>.  The sign of the distances indicate direction.
 	 *
 	 * @param lineSeg
 	 * @param ptOnLine
 	 * @param refPoint
 	 * @return the distance from <code>Point</code> on a <code>LineSeg</code> to another <code>Point</code>
 	 */
 	private static Point getOrthogonalDistances(LineSeg lineSeg, Point ptOnLine, Point refPoint) {
 		LineSeg parallelSeg = lineSeg.getParallelLineSegThroughPoint(refPoint);
 		Point p1 = parallelSeg.perpIntersect(ptOnLine.x, ptOnLine.y);
 		double dx = p1.getDistance(refPoint) * ((p1.x > refPoint.x) ? -1 : 1);
 		double dy = p1.getDistance(ptOnLine) * ((p1.y < ptOnLine.y) ? -1 : 1);
 		Point orth = new Point(dx, dy);
 		// Reflection in the y axis
 		if (lineSeg.getOrigin().x > lineSeg.getTerminus().x)
 			orth = orth.scale(-1, -1);
 		return orth;
 	}
 }
	/******************************************************************************
	* Copyright (c) 2005, 2009 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
	****************************************************************************/
	package org.eclipse.gmf.runtime.diagram.ui.internal.figures;

	import org.eclipse.draw2d.Connection;
	import org.eclipse.draw2d.IFigure;
	import org.eclipse.draw2d.geometry.Point;
	import org.eclipse.draw2d.geometry.PointList;
	import org.eclipse.draw2d.geometry.Rectangle;

	import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg;
	import org.eclipse.gmf.runtime.draw2d.ui.geometry.PointListUtilities;

	/**
	* Helper class to convert the label coordinates from an offset value
	* from a keypoint to real draw2d coordinate
	*
	* @author sshaw
	*
	*/
	public class LabelHelper {

	/**
	* Calculates the label offset from the reference point given the label bounds.
	*
	* @param label the <code>IFigure</code> to calculate the offset for
	* @param bounds the <code>Rectangle</code> that is the bounding box of the label.
	* @param ref the <code>Point</code> that is the reference point that the offset
	* is based on.
	* @return a <code>Point</code> which represents a value offset from the <code>ref</code>
	* point oriented based on the nearest line segment.
	*/
	static public Point offsetFromRelativeCoordinate(IFigure label, Rectangle bounds, Point ref) {
	return offsetFromRelativeCoordinate(label, bounds, getParentPointList(label), ref);
	}

	/**
	* Calculates the label offset from the reference point given the label bounds and a points list.
	*
	* @param label the <code>IFigure</code> to calculate the offset for
	* @param bounds the <code>Rectangle</code> that is the bounding box of the label.
	* @param points the <code>PointList</code> that contains that the label offset is relative to.
	* @param ref the <code>Point</code> that is the reference point that the offset
	* is based on.
	* @return a <code>Point</code> which represents a value offset from the <code>ref</code>
	* point oriented based on the nearest line segment.
	*/
	static private Point offsetFromRelativeCoordinate(IFigure label, Rectangle bounds, PointList points, Point ref) {
	Rectangle rect = new Rectangle(bounds);

	//Componsate for the fact that we are using the
	// figure center
	rect.translate(rect.width /2, rect.height /2);

	Point normalPoint = normalizeRelativePointToPointOnLine(points, ref,
	new Point(rect.x - ref.x, rect.y - ref.y));

	return normalPoint;
	}

	/**
	* Calculates the relative coordinate that is equivalent to the offset from the reference
	* point, that can be used to set the label location.
	*
	* @param label the <code>IFigure</code> to calculate the relative coordinate for
	* @param ref a <code>Point</code> located on the parent which the offset value
	* is relative to.
	* @param offset a <code>Point</code> which represents a value offset from the <code>ref</code>
	* point oriented based on the nearest line segment.
	* @return a <code>Point</code> that is the relative coordinate of the label that can be
	* used to set it's location.
	*/
	static public Point relativeCoordinateFromOffset(IFigure label, Point ref, Point offset) {
	return relativeCoordinateFromOffset(label, getParentPointList(label), ref, offset);
	}

	/**
	* Calculates the relative coordinate that is equivalent to the offset from the reference
	* point, that can be used to set the label location.
	*
	* @param label the <code>IFigure</code> to calculate the relative coordinate for
	* @param points the <code>PointList</code> that contains that the label offset is relative to.
	* @param ref a <code>Point</code> located on the parent which the offset value
	* is relative to.
	* @param offset a <code>Point</code> which represents a value offset from the <code>ref</code>
	* point oriented based on the nearest line segment.
	* @return a <code>Point</code> that is the relative coordinate of the label that can be
	* used to set it's location.
	*/
	static private Point relativeCoordinateFromOffset(IFigure label, PointList points, Point ref, Point offset) {
	Point location = calculatePointRelativeToPointOnLine(points, ref, offset);
	location.translate(-1 * label.getBounds().width /2, -1 * label.getBounds().height /2);
	return location;
	}

	/**
	* gets the point list using the passed figure to get the parent
	*
	* @param label the <code>IFigure</code> to use to retrieve the parent points
	* @return List of points
	*/
	static private PointList getParentPointList(IFigure label) {
	IFigure parent = label.getParent();
	if (parent instanceof Connection) {
	return ((Connection) parent).getPoints();
	} else {
	PointList ptList = new PointList();
	ptList.addPoint(parent.getBounds().getLocation());
	return ptList;
	}
	}

	/**
	* Returns a point located relative to the line by the given offset.
	*
	* @param ptLst the point
	* @param ptOnLine
	* @param offset
	* @return the relative point given the line angle
	*/
	protected static Point calculatePointRelativeToPointOnLine(PointList ptLst, Point ptOnLine, Point offset) {
	// Calculate slope of line
	if (ptLst.size() == 1) {
	// This is a node...
	return ptLst.getFirstPoint().getTranslated(offset);
	} else if (ptLst.size() >= 2){
	// This is a edge...
	int index = PointListUtilities.findNearestLineSegIndexOfPoint(ptLst, ptOnLine);
	if (index < 1) {
	return ptLst.getFirstPoint().getTranslated(offset);
	}
	LineSeg segment = (LineSeg) PointListUtilities.getLineSegments(ptLst).get(index - 1);
	Point relativeOffset = null;
	if (segment != null) {
	if (segment.isHorizontal()) {
	if (segment.getOrigin().x > segment.getTerminus().x) {
	relativeOffset = ptOnLine.getTranslated(offset.getNegated());
	//System.out.println("1. Relative offset: " + relativeOffset);//$NON-NLS-1$
	return relativeOffset;
	} else {
	relativeOffset = ptOnLine.getTranslated(offset);
	//System.out.println("2. Relative offset: " + relativeOffset);//$NON-NLS-1$
	return relativeOffset;
	}
	} else if (segment.isVertical()) {
	if (segment.getOrigin().y > segment.getTerminus().y) {
	relativeOffset = ptOnLine.getTranslated(offset.getCopy().scale(-1, 1).transpose());
	//System.out.println("3. Relative offset: " + relativeOffset);//$NON-NLS-1$
	return relativeOffset;
	} else {
	relativeOffset = ptOnLine.getTranslated(offset.getCopy().scale(1, -1).transpose());
	//System.out.println("4. Relative offset: " + relativeOffset);//$NON-NLS-1$
	return relativeOffset;
	}
	} else {
	double slope = segment.slope();
	double theta = Math.atan(slope);
	Point normalizedOffset = new Point(offset);
	Point calculatedOffset = new Point();
	if (segment.getOrigin().x > segment.getTerminus().x) {
	normalizedOffset = offset.getCopy().scale(-1, -1);
	}

	calculatedOffset = new Point(normalizedOffset.x
	* Math.cos(theta) - normalizedOffset.y
	* Math.sin(theta), normalizedOffset.x * Math.sin(theta)
	+ normalizedOffset.y * Math.cos(theta));
	relativeOffset = ptOnLine.getTranslated(calculatedOffset);
	//System.out.println("5. Relative offset: " + relativeOffset);//$NON-NLS-1$
	return relativeOffset;
	}
	}
	}
	return null;
	}

	/**
	* Calculates the normalized offset from a point on a <code>Connection</code>'s point list to an point.
	*
	* @param ptLst
	* @param ptOnLine
	* @param offset
	* @return the normalized offset
	*/
	private static Point normalizeRelativePointToPointOnLine(PointList ptLst, Point ptOnLine, Point offset) {
	// Calculate slope of line
	if (ptLst.size() == 1) {
	// This is a node...
	return offset;
	} else if (ptLst.size() >= 2){
	// This is a edge...
	int index = PointListUtilities.findNearestLineSegIndexOfPoint(ptLst, ptOnLine);
	LineSeg segment = (LineSeg) PointListUtilities.getLineSegments(ptLst).get(index - 1);
	Point normalOffset = null;
	if (segment != null) {
	if (segment.isHorizontal()) {
	if (segment.getOrigin().x > segment.getTerminus().x) {
	normalOffset = offset.getNegated();
	//System.out.println("1. Normal offset: " + normalOffset);//$NON-NLS-1$
	return normalOffset;
	} else {
	normalOffset = offset;
	//System.out.println("2. Normal offset: " + normalOffset);//$NON-NLS-1$
	return normalOffset;
	}
	} else if (segment.isVertical()) {
	if (segment.getOrigin().y < segment.getTerminus().y) {
	normalOffset = offset.scale(-1, 1).transpose();
	//System.out.println("3. Normal offset: " + normalOffset);//$NON-NLS-1$
	return normalOffset;
	} else {
	normalOffset = offset.scale(1, -1).transpose();
	//System.out.println("4. Normal offset: " + normalOffset);//$NON-NLS-1$
	return normalOffset;
	}
	} else {
	Point p = ptOnLine.getTranslated(offset);
	normalOffset = getOrthogonalDistances(segment, ptOnLine, p);
	//System.out.println("5. Normal offset: " + normalOffset);//$NON-NLS-1$
	return normalOffset;
	}
	}
	}
	return null;

	}

	/**
	* Calculates distances from a <code>Point</code> on a <code>LineSeg</code> to
	* another <code>Point</code>. The sign of the distances indicate direction.
	*
	* @param lineSeg
	* @param ptOnLine
	* @param refPoint
	* @return the distance from <code>Point</code> on a <code>LineSeg</code> to another <code>Point</code>
	*/
	private static Point getOrthogonalDistances(LineSeg lineSeg, Point ptOnLine, Point refPoint) {
	LineSeg parallelSeg = lineSeg.getParallelLineSegThroughPoint(refPoint);
	Point p1 = parallelSeg.perpIntersect(ptOnLine.x, ptOnLine.y);
	double dx = p1.getDistance(refPoint) * ((p1.x > refPoint.x) ? -1 : 1);
	double dy = p1.getDistance(ptOnLine) * ((p1.y < ptOnLine.y) ? -1 : 1);
	Point orth = new Point(dx, dy);
	// Reflection in the y axis
	if (lineSeg.getOrigin().x > lineSeg.getTerminus().x)
	orth = orth.scale(-1, -1);
	return orth;
	}
	}