| /****************************************************************************** |
| * Copyright (c) 2007, 2010 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.draw2d.ui.internal.routers; |
| |
| import java.util.ArrayList; |
| import java.util.Iterator; |
| import java.util.List; |
| |
| import org.eclipse.draw2d.AbsoluteBendpoint; |
| import org.eclipse.draw2d.AnchorListener; |
| import org.eclipse.draw2d.Bendpoint; |
| import org.eclipse.draw2d.Connection; |
| import org.eclipse.draw2d.ConnectionAnchor; |
| import org.eclipse.draw2d.Graphics; |
| import org.eclipse.draw2d.IFigure; |
| import org.eclipse.draw2d.LayoutManager; |
| import org.eclipse.draw2d.PositionConstants; |
| import org.eclipse.draw2d.geometry.Geometry; |
| import org.eclipse.draw2d.geometry.Point; |
| import org.eclipse.draw2d.geometry.PointList; |
| import org.eclipse.draw2d.geometry.PrecisionRectangle; |
| import org.eclipse.draw2d.geometry.Rectangle; |
| import org.eclipse.draw2d.graph.Path; |
| import org.eclipse.draw2d.graph.ShortestPathRouter; |
| import org.eclipse.gmf.runtime.draw2d.ui.figures.IBorderItemLocator; |
| import org.eclipse.gmf.runtime.draw2d.ui.figures.PolylineConnectionEx; |
| import org.eclipse.gmf.runtime.draw2d.ui.mapmode.IMapMode; |
| import org.eclipse.gmf.runtime.draw2d.ui.mapmode.MapModeUtil; |
| |
| /** |
| * @author mmostafa |
| * |
| * RectilinearRouter which is aware of border items |
| * This router, will make sure that it connects to teh correct side of teh border item |
| * Also, it willmake sure that it never overlape the border item container |
| * |
| */ |
| |
| public class BorderItemRectilinearRouter |
| extends RectilinearRouter { |
| |
| private static int OFFSET = 15; |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.gmf.runtime.draw2d.ui.internal.routers.ObliqueRouter#calculateBendPoints(org.eclipse.draw2d.Connection) |
| */ |
| protected PointList calculateBendPoints(Connection conn) { |
| IFigure source = conn.getSourceAnchor().getOwner(); |
| IFigure target = conn.getTargetAnchor().getOwner(); |
| PointList bends = super.calculateBendPoints(conn); |
| if (source == null || target == null || isAvoidingObstructions(conn) || isClosestDistance(conn) |
| || bends.size() > 2) { |
| // reorient |
| return bends; |
| } |
| |
| int sourcePosition = getBorderFigurePosition(source); |
| int targetPosition = getBorderFigurePosition(target); |
| |
| if (sourcePosition == PositionConstants.NONE && targetPosition == PositionConstants.NONE) { |
| return bends; |
| } |
| |
| PolylineConnectionEx fakeConnection = new PolylineConnectionEx() { |
| |
| public void validate() { |
| // no need to validate |
| } |
| |
| public void paintFigure(Graphics graphics) { |
| // nothing to paint |
| } |
| }; |
| Rectangle sourceParentRect = getObstacle(source, conn, (sourcePosition != PositionConstants.NONE)); |
| Rectangle targetParentRect = getObstacle(target, conn, (targetPosition != PositionConstants.NONE)); |
| if (bends.size() == 2 |
| && (sourcePosition == PositionConstants.NONE || (sourcePosition != PositionConstants.NONE && !lineIntersectRectangle(bends.getFirstPoint(), bends.getLastPoint(), sourceParentRect))) |
| && (targetPosition == PositionConstants.NONE || (targetPosition != PositionConstants.NONE && !lineIntersectRectangle(bends.getFirstPoint(), bends.getLastPoint(), targetParentRect)))) { |
| return bends; |
| } |
| if (sourceParentRect.contains(targetParentRect)) { |
| sourcePosition = reversePosition(sourcePosition); |
| } else if (targetParentRect.contains(sourceParentRect)) { |
| targetPosition = reversePosition(targetPosition); |
| } |
| |
| fakeConnection.setSourceAnchor(new BorderItemConnectionAnchor(conn |
| .getSourceAnchor(), sourcePosition, OFFSET)); |
| fakeConnection.setTargetAnchor(new BorderItemConnectionAnchor(conn |
| .getTargetAnchor(), targetPosition, OFFSET)); |
| |
| fakeConnection.setConnectionRouter(conn.getConnectionRouter()); |
| List originalbendpoints = (ArrayList) conn.getConnectionRouter() |
| .getConstraint(conn); |
| // protection code to prevent NPE while creating the connection |
| if (originalbendpoints == null || originalbendpoints.size() == 0) { |
| // reorient |
| return bends; |
| } |
| |
| fakeConnection.setParent(conn.getParent()); |
| if (conn instanceof PolylineConnectionEx) { |
| PolylineConnectionEx connection = (PolylineConnectionEx) conn; |
| fakeConnection.setRoutingStyles(connection |
| .isClosestDistanceRouting(), connection |
| .isAvoidObstacleRouting()); |
| } |
| List constraint = new ArrayList(); |
| for (Iterator itr = originalbendpoints.iterator(); itr.hasNext();) { |
| Bendpoint bp = (Bendpoint) itr.next(); |
| constraint.add(new AbsoluteBendpoint(bp.getLocation())); |
| } |
| AbsoluteBendpoint startPoint = (AbsoluteBendpoint) constraint.get(0); |
| if (sourcePosition != PositionConstants.NONE) { |
| BorderItemConnectionAnchor anchor = (BorderItemConnectionAnchor) fakeConnection |
| .getSourceAnchor(); |
| Point startBendpoint = anchor.getReferencePoint(); |
| conn.translateToRelative(startBendpoint); |
| constraint.remove(0); |
| startPoint = new AbsoluteBendpoint(startBendpoint); |
| constraint.add(0, startPoint); |
| } |
| AbsoluteBendpoint endPoint = (AbsoluteBendpoint) constraint |
| .get(constraint.size() - 1); |
| if (targetPosition != PositionConstants.NONE) { |
| BorderItemConnectionAnchor anchor = (BorderItemConnectionAnchor) fakeConnection |
| .getTargetAnchor(); |
| Point endBendpoint = anchor.getReferencePoint(); |
| conn.translateToRelative(endBendpoint); |
| constraint.remove(constraint.size() - 1); |
| endPoint = new AbsoluteBendpoint(endBendpoint); |
| constraint.add(endPoint); |
| } |
| avoidOverlappingWithParent(startPoint, endPoint, sourceParentRect, |
| targetParentRect, constraint, conn); |
| fakeConnection.setRoutingConstraint(constraint); |
| PointList points = super.calculateBendPoints(fakeConnection); |
| if (sourcePosition != PositionConstants.NONE) { |
| BorderItemConnectionAnchor anchor = (BorderItemConnectionAnchor) fakeConnection |
| .getSourceAnchor(); |
| Point startPoint1 = anchor.getAnchorPoint(); |
| conn.translateToRelative(startPoint1); |
| points.insertPoint(startPoint1, 0); |
| } |
| |
| if (targetPosition != PositionConstants.NONE) { |
| BorderItemConnectionAnchor anchor = (BorderItemConnectionAnchor) fakeConnection |
| .getTargetAnchor(); |
| Point endPoint1 = anchor.getAnchorPoint(); |
| conn.translateToRelative(endPoint1); |
| points.addPoint(endPoint1); |
| } |
| fakeConnection.setParent(null); |
| return points; |
| } |
| |
| /** |
| * utility method to revers the position |
| * @param position the position to reverse |
| * @return teh reversed position |
| */ |
| private int reversePosition(int position) { |
| int newPosition = position; |
| if (position == PositionConstants.SOUTH) |
| newPosition = PositionConstants.NORTH; |
| else if (position == PositionConstants.NORTH) |
| newPosition = PositionConstants.SOUTH; |
| else if (position == PositionConstants.WEST) |
| newPosition = PositionConstants.EAST; |
| else if (position == PositionConstants.EAST) |
| newPosition = PositionConstants.WEST; |
| return newPosition; |
| } |
| |
| /** |
| * @author MMostafa |
| * Border Item aware Anchor, this anchor will make sure that the anchor point |
| * and the reference point are on the correct side |
| */ |
| private class BorderItemConnectionAnchor |
| implements ConnectionAnchor { |
| |
| private ConnectionAnchor anchor; |
| |
| private int position; |
| |
| private int offset; |
| |
| public BorderItemConnectionAnchor(ConnectionAnchor anchor, |
| int position, int offset) { |
| this.anchor = anchor; |
| this.position = position; |
| this.offset = offset; |
| } |
| |
| public Point getReferencePoint() { |
| Point referencePoint = getAnchorPoint(); |
| if (position == PositionConstants.SOUTH) |
| referencePoint.y += offset; |
| else if (position == PositionConstants.NORTH) |
| referencePoint.y -= offset; |
| else if (position == PositionConstants.WEST) |
| referencePoint.x -= offset; |
| else if (position == PositionConstants.EAST) |
| referencePoint.x += offset; |
| return referencePoint; |
| } |
| |
| public Point getAnchorPoint() { |
| Rectangle ownerBounds = getOwner().getBounds().getCopy(); |
| getOwner().translateToAbsolute(ownerBounds); |
| if (position == PositionConstants.SOUTH) |
| return ownerBounds.getBottom(); |
| else if (position == PositionConstants.NORTH) |
| return ownerBounds.getTop(); |
| else if (position == PositionConstants.WEST) |
| return ownerBounds.getLeft(); |
| else if (position == PositionConstants.EAST) |
| return ownerBounds.getRight(); |
| return ownerBounds.getCenter(); |
| } |
| |
| public void addAnchorListener(AnchorListener listener) { |
| // nothing to do |
| } |
| |
| public Point getLocation(Point reference) { |
| return reference; |
| } |
| |
| public IFigure getOwner() { |
| return anchor.getOwner(); |
| } |
| |
| public void removeAnchorListener(AnchorListener listener) { |
| // nothing to do |
| } |
| |
| } |
| |
| /** |
| * Returns the position of the border item with respect to its parent |
| * Clients can override this method to change the way postions is |
| * calculated for border items |
| * @param borderFigure Figure to use to get the position |
| * @return the border item position, see <code>PositionConstants</code> |
| */ |
| protected int getBorderFigurePosition(IFigure borderFigure) { |
| IFigure child = borderFigure; |
| IFigure parent = borderFigure.getParent(); |
| if (parent != null && parent.getLayoutManager() != null) { |
| LayoutManager layoutManager = parent.getLayoutManager(); |
| Object layoutConstraint = layoutManager.getConstraint(child); |
| if (layoutConstraint instanceof IBorderItemLocator) { |
| return ((IBorderItemLocator) layoutConstraint) |
| .getCurrentSideOfParent(); |
| } |
| } |
| return PositionConstants.NONE; |
| } |
| |
| |
| |
| /** |
| * Utility method that adjust the constrinat to avoid overlapping with |
| * Source or target parents, this method should be called only in case |
| * of routing connections connecting to border items |
| * @param startPoint start point or the route |
| * @param endPoint end point of the route |
| * @param sourceParentRect the rectangle of the source element parent |
| * @param targetParentRect the rectangle of the target element parent |
| * @param constraint the constraint to modify |
| * @param conn the connection to route |
| */ |
| private void avoidOverlappingWithParent(AbsoluteBendpoint startPoint, |
| AbsoluteBendpoint endPoint, Rectangle sourceParentRect, |
| Rectangle targetParentRect, List constraint, Connection conn) { |
| if (sourceParentRect.intersects(targetParentRect)) { |
| return; |
| } |
| IMapMode mapMode = MapModeUtil.getMapMode(conn); |
| int logicalOffset = mapMode.DPtoLP(OFFSET); |
| // use GEF's shortest path router to get reference bend points |
| ShortestPathRouter router = new ShortestPathRouter(); |
| Path path = new Path(startPoint, endPoint); |
| router.addPath(path); |
| router.addObstacle(sourceParentRect); |
| router.addObstacle(targetParentRect); |
| router.setSpacing(logicalOffset); |
| router.solve(); |
| PointList points = path.getPoints(); |
| // remove the start and end points |
| points.removePoint(0); |
| points.removePoint(points.size() - 1); |
| // deal with the remaining points |
| if (points.size() > 0) { |
| Point refrencePoint = points.getFirstPoint(); |
| AbsoluteBendpoint startPointGuidePoint = new AbsoluteBendpoint(startPoint); |
| adjustPointUsingReferencePointAndObstacle(startPointGuidePoint,refrencePoint,sourceParentRect, logicalOffset); |
| constraint.add(1, startPointGuidePoint); |
| points.removePoint(0); |
| // this means we had only one reference point, we will use this point |
| // to adjust poth source and target |
| if (points.size() == 0) { |
| AbsoluteBendpoint endPointGuidePoint = new AbsoluteBendpoint(endPoint); |
| adjustPointUsingReferencePointAndObstacle(endPointGuidePoint,refrencePoint,targetParentRect, logicalOffset); |
| if (endPointGuidePoint.y == endPoint.y) |
| endPointGuidePoint.x = startPointGuidePoint.x; |
| else |
| endPointGuidePoint.y = startPointGuidePoint.y; |
| constraint.add(2, endPointGuidePoint); |
| } |
| } |
| if (points.size() > 0) { |
| Point referencePoint = points.getLastPoint(); |
| AbsoluteBendpoint endPointGuidePoint = new AbsoluteBendpoint(endPoint); |
| adjustPointUsingReferencePointAndObstacle(endPointGuidePoint,referencePoint,targetParentRect , logicalOffset); |
| constraint.add(constraint.size() - 1, endPointGuidePoint); |
| } |
| } |
| |
| /** |
| * Modify a guide point based on a reference point to avoid collision with the |
| * passed obstacle, the offset had to be in logical coordinates |
| * @param guidePoint, the point to adjust |
| * @param referencePoint, reference point to use during the adjust process |
| * @param obstacle, obstable to consider |
| * @param offSet, the offset had to be in logical coordinate |
| */ |
| private void adjustPointUsingReferencePointAndObstacle(AbsoluteBendpoint guidePoint, Point referencePoint, |
| Rectangle obstacle, int offSet ) { |
| // check if the y of the starting point is in the rectangle range (point |
| // will be west or east or the rectangle) |
| boolean changeY = (guidePoint.y >= obstacle.y && guidePoint.y <= (obstacle.y + obstacle.height)); |
| |
| if (changeY) { |
| if (referencePoint.y < guidePoint.y) |
| guidePoint.y = obstacle.y - offSet; |
| else |
| guidePoint.y = obstacle.y + obstacle.height |
| + offSet; |
| } else { |
| if (referencePoint.x < guidePoint.x) |
| guidePoint.x = obstacle.x - offSet; |
| else |
| guidePoint.x = obstacle.x + obstacle.width |
| + offSet; |
| } |
| } |
| |
| /** |
| * Returns the obstacle that the route should try to avoid, for example if the isBordereItem |
| * flag is ON, it will return the rectangle of the border item parent. |
| * This method can be overriden by clients to provide a client specific way to find the obstacle |
| * @param figure, figure to get the obstacle for |
| * @param conn, the connection the router is routing |
| * @param isBorderItem, indicates if the passed figure is a border item figrue or not |
| * @return obstacle |
| */ |
| protected Rectangle getObstacle(IFigure figure, Connection conn, |
| boolean isBorderItem) { |
| IFigure parent = null; |
| if (isBorderItem) |
| parent = getBorderItemParent(figure); |
| else |
| parent = figure; |
| Rectangle rect = new PrecisionRectangle(parent.getBounds()); |
| parent.translateToAbsolute(rect); |
| conn.translateToRelative(rect); |
| return rect; |
| } |
| |
| /** |
| * return the parent of a border item figure |
| * clients can override this method to find the |
| * @param figure, the border item figure |
| * @return teh parent of the border item |
| */ |
| protected IFigure getBorderItemParent(IFigure figure) { |
| return figure.getParent().getParent(); |
| } |
| |
| private boolean lineIntersectRectangle(Point start, Point end, Rectangle rect) { |
| return Geometry.linesIntersect(start.x, start.y, end.x, end.y, rect.x, rect.y, rect.x + rect.width, rect.y) |
| || Geometry.linesIntersect(start.x, start.y, end.x, end.y, rect.x + rect.width, rect.y, rect.x + rect.width, rect.y + rect.height) |
| || Geometry.linesIntersect(start.x, start.y, end.x, end.y, rect.x + rect.width, rect.y + rect.height, rect.x, rect.y + rect.height) |
| || Geometry.linesIntersect(start.x, start.y, end.x, end.y, rect.x, rect.y + rect.height, rect.x, rect.y); |
| } |
| } |
