org.eclipse.gmf.runtime.draw2d.ui/src/org/eclipse/gmf/runtime/draw2d/ui/internal/routers/TreeRouter.java - gmf-runtime/org.eclipse.gmf-runtime - Git at Google

 /******************************************************************************
  * Copyright (c) 2004, 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
  *    Mariot Chauvin <mariot.chauvin@obeo.fr> - bug 233344
  ****************************************************************************/


 package org.eclipse.gmf.runtime.draw2d.ui.internal.routers;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.ListIterator;

 import org.eclipse.draw2d.AbsoluteBendpoint;
 import org.eclipse.draw2d.Bendpoint;
 import org.eclipse.draw2d.BendpointConnectionRouter;
 import org.eclipse.draw2d.Connection;
 import org.eclipse.draw2d.ConnectionAnchor;
 import org.eclipse.draw2d.geometry.Dimension;
 import org.eclipse.draw2d.geometry.Point;
 import org.eclipse.draw2d.geometry.PointList;
 import org.eclipse.draw2d.geometry.Rectangle;
 import org.eclipse.gmf.runtime.common.core.util.Trace;
 import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg;
 import org.eclipse.gmf.runtime.draw2d.ui.internal.Draw2dDebugOptions;
 import org.eclipse.gmf.runtime.draw2d.ui.internal.Draw2dPlugin;
 import org.eclipse.gmf.runtime.draw2d.ui.mapmode.MapModeUtil;

 /**
  * This class is a top level router for managing the individual branches in a set of
  * tree routed connections.
  *
  * @author sshaw
  */
 public class TreeRouter extends BendpointConnectionRouter implements OrthogonalRouter {

 	private BranchRouter branchRouter = new BranchRouter(this);
 	private ArrayList connectionList = new ArrayList();
 	private Dimension trunkVertex;
 	private Orientation trunkOrientation;
 	private boolean updatingPeers = false;

 	static private class Orientation {

 		private Orientation() {
 			// Empty constructor
 		}

 		/**
 		 * Constant for the top orientation
 		 */
 		static public Orientation TOP = new Orientation();

 		/**
 		 * Constant for the bottom orientation
 		 */
 		static public Orientation BOTTOM = new Orientation();

 		/**
 		 * Constant for the right orientation
 		 */
 		static public Orientation RIGHT = new Orientation();

 		/**
 		 * Constant for the left orientation
 		 */
 		static public Orientation LEFT = new Orientation();

 		/**
 		 * getEdge
 		 * Method to return the edge point of the given Rectangle representative
 		 * of the orientation value of the instance.
 		 *
 		 * @param bounds Rectangle to retrieve the edge value from.
 		 * @return Point that is the edge of the rectangle for the orientation of this.
 		 */
 		public Point getEdge(Rectangle bounds) {
 			if (this == TOP)
 				return bounds.getTop();
 			else if (this == BOTTOM)
 				return bounds.getBottom();
 			else if (this == RIGHT)
 				return bounds.getRight();

 			return bounds.getLeft();
 		}
 	}

 	/**
 	 *
 	 */
 	public TreeRouter() {
 		super();
 	}


 	/**
 	 * @see org.eclipse.draw2d.ConnectionRouter#invalidate(Connection)
 	 */
 	public void invalidate(Connection conn) {
 		if (conn.getSourceAnchor() == null || conn.getSourceAnchor().getOwner() == null ||
 			conn.getTargetAnchor() == null || conn.getTargetAnchor().getOwner() == null)
 			return;

 		ListIterator li = connectionList.listIterator();
 		while (li.hasNext()) {
 			Connection connNext = (Connection)li.next();

 			if (!trunkVertexEqual(connNext, conn)) {
 				final ConnectionAnchor connExtSourceAnchor = connNext.getSourceAnchor();
 				final ConnectionAnchor connExtTargetAnchor = connNext.getTargetAnchor();
 				if (connExtSourceAnchor != null && connExtSourceAnchor.getOwner() != null &&
 						connExtTargetAnchor != null && connExtTargetAnchor.getOwner() != null){
 					updateConstraint(connNext);
 				}
 			}
 		}
 	}

 	private boolean trunkVertexEqual(Connection connMaster, Connection connSlave) {
 		PointList cmPts = connMaster.getPoints();
 		PointList csPts = connSlave.getPoints();
 		if (cmPts.size() > 2 && csPts.size() > 2)
 			return cmPts.getPoint(2).equals(csPts.getPoint(2));

 		return false;
 	}

 	private Rectangle getTargetAnchorRelativeBounds(final Connection conn) {
 		final Rectangle bounds = conn.getTargetAnchor().getOwner().getBounds().getCopy();
 		conn.getTargetAnchor().getOwner().translateToAbsolute(bounds);
 		conn.translateToRelative(bounds);
 		return bounds;
 	}

 	private Rectangle getSourceAnchorRelativeBounds(final Connection conn) {
 		final Rectangle bounds = conn.getSourceAnchor().getOwner().getBounds().getCopy();
 		conn.getSourceAnchor().getOwner().translateToAbsolute(bounds);
 		conn.translateToRelative(bounds);
 		return bounds;
 	}


 	/**
 	 * getTrunkLocation
 	 * Method to retrieve the trunk location in relative coordinates based on
 	 * current tree state.
 	 *
 	 * @param conn Connection being routed
 	 * @return Point that is the trunk location in relative coordinates.
 	 */
 	public Point getTrunkLocation(Connection conn) {
 		Dimension vertex = getTrunkVertex();
 		Point target = getTrunkOrientation().getEdge(getTargetAnchorRelativeBounds(conn));

 		Point ptTrunkLoc = new Point(vertex.width, vertex.height);
 		ptTrunkLoc = ptTrunkLoc.getTranslated(target);

 		return ptTrunkLoc;
 	}

 	/**
 	 * setTrunkLocation
 	 * Setter method to set the trunk location.  Translates the point into a relative
 	 * point from the target edge.
 	 *
 	 * @param conn Connection being routed
 	 * @param ptTrunkLoc Point that is the trunk location in relative coordinates.
 	 */
 	public void setTrunkLocation(Connection conn, Point ptTrunkLoc) {
 		Point ptRelTrunkLoc = new Point(ptTrunkLoc);

 		final Rectangle targetAnchorBounds = getTargetAnchorRelativeBounds(conn);

 		// update orientation
 		if (isTopDown(conn)) {
 			if (ptTrunkLoc.y < targetAnchorBounds.getCenter().y)
 				setTrunkOrientation(Orientation.TOP);
 			else
 				setTrunkOrientation(Orientation.BOTTOM);
 		}
 		else {
 			if (ptTrunkLoc.x < targetAnchorBounds.getCenter().x)
 				setTrunkOrientation(Orientation.LEFT);
 			else
 				setTrunkOrientation(Orientation.RIGHT);
 		}

 		Point target = getTrunkOrientation().getEdge(targetAnchorBounds);

 		Dimension currentVertex = ptRelTrunkLoc.getDifference(target);
 		setTrunkVertex(currentVertex);
 	}

 	/**
 	 * updateConstraint
 	 * Updates the constraint value for the connection based on the tree vertex
 	 *
 	 * @param conn Connection whose constraint is to be updated.
 	 */
 	protected void updateConstraint(Connection conn) {
 		if (isUpdatingPeers())
 			return;

 		List bendpoints = (List)conn.getRoutingConstraint();
 		if (bendpoints == null)
 			bendpoints = new ArrayList(conn.getPoints().size());

 		if (bendpoints != null) {
 			Point sourceRefPoint = conn.getSourceAnchor().getReferencePoint();
 			conn.translateToRelative(sourceRefPoint);

 			Point targetRefPoint = conn.getTargetAnchor().getReferencePoint();
 			conn.translateToRelative( targetRefPoint);

 			Point ptTrunk = getTrunkLocation(conn);
 			Point ptSource = getBranchRouter().getSourceLocation(conn, ptTrunk);

 			bendpoints.clear();
 			PointList pts = getBranchRouter().recreateBranch(conn, ptSource, ptTrunk);
 			for (int i=0; i<pts.size(); i++) {
 				Bendpoint bp = new AbsoluteBendpoint(pts.getPoint(i));
 				bendpoints.add(bp);
 			}
 		}

 		setUpdatingPeers(true);

 		try {
 			setConstraint(conn, bendpoints);
 			conn.invalidate();
 			conn.validate();
 		}
 		catch (Exception e) {
 			Trace.catching(Draw2dPlugin.getInstance(), Draw2dDebugOptions.EXCEPTIONS_CATCHING, TreeRouter.class, "updateConstraint", //$NON-NLS-1$
 				e);
 		}
 		finally {
 			setUpdatingPeers(false);
 		}
 	}

 	/**
 	 * getPointsFromConstraint
 	 * Utility method retrieve the PointList equivalent of the bendpoint constraint
 	 * set in the Connection.
 	 *
 	 * @param conn Connection to retrieve the constraint from.
 	 * @return PointList list of points that is the direct equivalent of the set constraint.
 	 */
 	public PointList getPointsFromConstraint(Connection conn) {
 		List bendpoints = (List)conn.getRoutingConstraint();
 		if (bendpoints == null)
 			return new PointList();

 		PointList points = new PointList(bendpoints.size());
 		for (int i = 0; i < bendpoints.size(); i++) {
 			Bendpoint bp = (Bendpoint) bendpoints.get(i);
 			points.addPoint(bp.getLocation());
 		}

 		straightenPoints(points, MapModeUtil.getMapMode(conn).DPtoLP(3));
 		return points;
 	}

     /**
      * straightenPoints
      * This is a simpler version of the @see updateIfNotRectilinear that simply ensures
      * that the lines are horizontal or vertical without any intelligence in terms of
      * shortest distance around a rectangle.
      *
 	 * @param newLine PointList to check for rectilinear qualities and change if necessary.
 	 * @param tolerance int tolerance value by which points will be straightened in HiMetrics
 	 */
 	static protected void straightenPoints(PointList newLine, int tolerance) {
         for (int i=0; i<newLine.size()-1; i++) {
             Point ptCurrent = newLine.getPoint(i);
             Point ptNext = newLine.getPoint(i+1);

             int xDelta = Math.abs(ptNext.x - ptCurrent.x);
             int yDelta = Math.abs(ptNext.y - ptCurrent.y);

             if (xDelta < yDelta) {
             	if (xDelta > tolerance)
             		return;
                 ptNext.x = ptCurrent.x;
             } else {
             	if (yDelta > tolerance)
             		return;
                 ptNext.y = ptCurrent.y;
             }

             newLine.setPoint(ptNext, i+1);
         }
     }

 	/**
 	 * Returns the branch router in the chain.
 	 * @return The getBranchRouter router
 	 *
 	 */
 	protected BranchRouter getBranchRouter() {
 		return branchRouter;
 	}

 	/**
 	 * @see org.eclipse.draw2d.ConnectionRouter#remove(Connection)
 	 */
 	public void remove(Connection conn) {
 		if (conn.getSourceAnchor() == null || conn.getTargetAnchor() == null)
 			return;

 		int index = connectionList.indexOf(conn);
 		connectionList.remove(conn);
 		for (int i = index + 1; i < connectionList.size(); i++)
 			((Connection)connectionList.get(i)).revalidate();

 		getBranchRouter().remove(conn);
 	}

 	/**
 	 * isTopDown
 	 * Utility method to determine if the connection should routed in a top-down fashion
 	 * or in a horizontal fashion.
      *
 	 * @param conn Connection to query
 	 * @return boolean true if connection should be routed top-down, false otherwise.
 	 */
 	public boolean isTopDown(Connection conn) {
 		boolean vertical = true;
 		if (conn instanceof ITreeConnection) {
 			vertical = ((ITreeConnection)conn).getOrientation().equals(ITreeConnection.Orientation.VERTICAL) ? vertical = true : false;
 		}

 		return vertical;
 	}

 	private int DEFAULT_TRUNK_HEIGHT = 32;

 	/**
 	 * checkTrunkVertex
 	 * Method to initialize the trunk vertex to a default value if not already set
 	 *
 	 * @param conn Connection to be routed.
 	 */
 	private void checkTrunkVertex(Connection conn) {
 		if (getTrunkVertex() == null) {
 			Rectangle sourceRect = conn.getSourceAnchor().getOwner().getBounds();
 			Rectangle targetRect = conn.getTargetAnchor().getOwner().getBounds();

 			Dimension default_trunk = new Dimension(0, DEFAULT_TRUNK_HEIGHT);
 			conn.translateToRelative(default_trunk);

 			if (isTopDown(conn)) {
 				if (sourceRect.getCenter().y < targetRect.getCenter().y) {
 					setTrunkVertex(new Dimension(0, -default_trunk.height));
 					setTrunkOrientation(Orientation.TOP);
 				}
 				else {
 					setTrunkVertex(new Dimension(0, default_trunk.height));
 					setTrunkOrientation(Orientation.BOTTOM);
 				}
 			}
 			else {
 				if (sourceRect.getCenter().x < targetRect.getCenter().x) {
 					setTrunkVertex(new Dimension(-default_trunk.height, 0));
 					setTrunkOrientation(Orientation.LEFT);
 				}
 				else {
 					setTrunkVertex(new Dimension(default_trunk.height, 0));
 					setTrunkOrientation(Orientation.RIGHT);
 				}
 			}
 		}
 	}

 	/* (non-Javadoc)
 	 * Routes the given connection.  Calls the 'getBranchRouter' router method first
 	 * @see org.eclipse.draw2d.ConnectionRouter#route(org.eclipse.draw2d.Connection)
 	 */
 	public void route(Connection conn) {

 		if (conn.getSourceAnchor() == null || conn.getSourceAnchor().getOwner() == null ||
 			conn.getTargetAnchor() == null || conn.getTargetAnchor().getOwner() == null) {
 			super.route(conn);
 			return;
 		}

 		if (!connectionList.contains(conn)) {
 			connectionList.add(conn);
 		}

 		checkTrunkVertex(conn);

 		getBranchRouter().route(conn);
 		invalidate(conn);
 	}

 	/**
 	 * @return Returns the truckVertex.
 	 */
 	protected Dimension getTrunkVertex() {
 		return trunkVertex;
 	}

 	/**
 	 * @param trunkVertex The trunkVertex to set.
 	 */
 	protected void setTrunkVertex(Dimension trunkVertex) {
 		this.trunkVertex = trunkVertex;
 	}

 	/**
 	 * @return Returns the trunkOrientation.
 	 */
 	protected Orientation getTrunkOrientation() {
 		return trunkOrientation;
 	}

 	/**
 	 * @param trunkOrientation The trunkOrientation to set.
 	 */
 	protected void setTrunkOrientation(Orientation trunkOrientation) {
 		this.trunkOrientation = trunkOrientation;
 	}

 	/**
 	 * Utility method to determine if the given set of points conforms to the constraints
 	 * of being an orthogonal connection tree-branch.
 	 * 1. Points size must be 4.
 	 * 2. Source point resides with-in boundary of source shape based on orientation
 	 * 3. Target point resides with-in boundary of target shape based on orientation
 	 * 4. Middle line is perpendicular to the 2 end lines.
 	 *
 	 * @param conn the <code>Connection</code> to test
 	 * @param points <code>PointList</code> to test constraints against
 	 * @return <code>boolean</code> <code>true</code> if points represent valid orthogaonl tree
 	 * branch, <code>false</code> otherwise.
 	 */
 	public boolean isOrthogonalTreeBranch(Connection conn, PointList points) {
 		if (isTreeBranch(conn, points)) {
 			LineSeg branch = new LineSeg(points.getPoint(0), points.getPoint(1));
 			LineSeg trunkShoulder = new LineSeg(points.getPoint(1), points.getPoint(2));
 			LineSeg trunk = new LineSeg(points.getPoint(2), points.getPoint(3));

 			if (isTopDown(conn))
 				return branch.isVertical() && trunkShoulder.isHorizontal() && trunk.isVertical();
 			else
 				return branch.isHorizontal() && trunkShoulder.isVertical() && trunk.isHorizontal();
 		}

 		return false;
 	}

 	/**
 	 * Utility method to determine if the given set of points conforms to the constraints
 	 * of being a connection tree-branch.
 	 * 1. Points size must be 4.
 	 * 2. Source point resides with-in boundary of source shape based on orientation
 	 * 3. Target point resides with-in boundary of target shape based on orientation
 	 *
 	 * @param conn the <code>Connection</code> to test
 	 * @param points the <code>PointList</code> to test constraints against
 	 * @return <code>boolean</code> <code>true</code> if points represent valid tree branch,
 	 * <code>false</code> otherwise.
 	 */
 	public boolean isTreeBranch(Connection conn, PointList points) {
 		if (points.size() == 4) {
 			// just check if ends are with-in the owner bounding box
 			Rectangle targetBounds = getTargetAnchorRelativeBounds(conn);
 			Rectangle sourceBounds = getSourceAnchorRelativeBounds(conn);

 			if (isTopDown(conn)) {
 				return (points.getPoint(0).x > sourceBounds.x &&
 					    points.getPoint(0).x < sourceBounds.x + sourceBounds.width) &&
 					   (points.getPoint(3).x > targetBounds.x &&
 						points.getPoint(3).x < targetBounds.x + targetBounds.width);
 			}
 			else
 			{
 				return (points.getPoint(0).y > sourceBounds.y &&
 					    points.getPoint(0).y < sourceBounds.y + sourceBounds.height) &&
 					   (points.getPoint(3).y > targetBounds.y &&
 						points.getPoint(3).y < targetBounds.y + targetBounds.height);
 			}
 		}

 		return false;
 	}

 	/**
 	 * @return Returns the connectionList List which is a copy of the internal list.
 	 */
 	public List getConnectionList() {
 		return (List)connectionList.clone();
 	}
 	/**
 	 * @return Returns the updatingPeers.
 	 */
 	protected boolean isUpdatingPeers() {
 		return updatingPeers;
 	}
 	/**
 	 * @param updatingPeers The updatingPeers to set.
 	 */
 	protected void setUpdatingPeers(boolean updatingPeers) {
 		this.updatingPeers = updatingPeers;
 	}
 }
	/******************************************************************************
	* Copyright (c) 2004, 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
	* Mariot Chauvin <mariot.chauvin@obeo.fr> - bug 233344
	****************************************************************************/


	package org.eclipse.gmf.runtime.draw2d.ui.internal.routers;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.ListIterator;

	import org.eclipse.draw2d.AbsoluteBendpoint;
	import org.eclipse.draw2d.Bendpoint;
	import org.eclipse.draw2d.BendpointConnectionRouter;
	import org.eclipse.draw2d.Connection;
	import org.eclipse.draw2d.ConnectionAnchor;
	import org.eclipse.draw2d.geometry.Dimension;
	import org.eclipse.draw2d.geometry.Point;
	import org.eclipse.draw2d.geometry.PointList;
	import org.eclipse.draw2d.geometry.Rectangle;
	import org.eclipse.gmf.runtime.common.core.util.Trace;
	import org.eclipse.gmf.runtime.draw2d.ui.geometry.LineSeg;
	import org.eclipse.gmf.runtime.draw2d.ui.internal.Draw2dDebugOptions;
	import org.eclipse.gmf.runtime.draw2d.ui.internal.Draw2dPlugin;
	import org.eclipse.gmf.runtime.draw2d.ui.mapmode.MapModeUtil;

	/**
	* This class is a top level router for managing the individual branches in a set of
	* tree routed connections.
	*
	* @author sshaw
	*/
	public class TreeRouter extends BendpointConnectionRouter implements OrthogonalRouter {

	private BranchRouter branchRouter = new BranchRouter(this);
	private ArrayList connectionList = new ArrayList();
	private Dimension trunkVertex;
	private Orientation trunkOrientation;
	private boolean updatingPeers = false;

	static private class Orientation {

	private Orientation() {
	// Empty constructor
	}

	/**
	* Constant for the top orientation
	*/
	static public Orientation TOP = new Orientation();

	/**
	* Constant for the bottom orientation
	*/
	static public Orientation BOTTOM = new Orientation();

	/**
	* Constant for the right orientation
	*/
	static public Orientation RIGHT = new Orientation();

	/**
	* Constant for the left orientation
	*/
	static public Orientation LEFT = new Orientation();

	/**
	* getEdge
	* Method to return the edge point of the given Rectangle representative
	* of the orientation value of the instance.
	*
	* @param bounds Rectangle to retrieve the edge value from.
	* @return Point that is the edge of the rectangle for the orientation of this.
	*/
	public Point getEdge(Rectangle bounds) {
	if (this == TOP)
	return bounds.getTop();
	else if (this == BOTTOM)
	return bounds.getBottom();
	else if (this == RIGHT)
	return bounds.getRight();

	return bounds.getLeft();
	}
	}

	/**
	*
	*/
	public TreeRouter() {
	super();
	}


	/**
	* @see org.eclipse.draw2d.ConnectionRouter#invalidate(Connection)
	*/
	public void invalidate(Connection conn) {
	if (conn.getSourceAnchor() == null \|\| conn.getSourceAnchor().getOwner() == null \|\|
	conn.getTargetAnchor() == null \|\| conn.getTargetAnchor().getOwner() == null)
	return;

	ListIterator li = connectionList.listIterator();
	while (li.hasNext()) {
	Connection connNext = (Connection)li.next();

	if (!trunkVertexEqual(connNext, conn)) {
	final ConnectionAnchor connExtSourceAnchor = connNext.getSourceAnchor();
	final ConnectionAnchor connExtTargetAnchor = connNext.getTargetAnchor();
	if (connExtSourceAnchor != null && connExtSourceAnchor.getOwner() != null &&
	connExtTargetAnchor != null && connExtTargetAnchor.getOwner() != null){
	updateConstraint(connNext);
	}
	}
	}
	}

	private boolean trunkVertexEqual(Connection connMaster, Connection connSlave) {
	PointList cmPts = connMaster.getPoints();
	PointList csPts = connSlave.getPoints();
	if (cmPts.size() > 2 && csPts.size() > 2)
	return cmPts.getPoint(2).equals(csPts.getPoint(2));

	return false;
	}

	private Rectangle getTargetAnchorRelativeBounds(final Connection conn) {
	final Rectangle bounds = conn.getTargetAnchor().getOwner().getBounds().getCopy();
	conn.getTargetAnchor().getOwner().translateToAbsolute(bounds);
	conn.translateToRelative(bounds);
	return bounds;
	}

	private Rectangle getSourceAnchorRelativeBounds(final Connection conn) {
	final Rectangle bounds = conn.getSourceAnchor().getOwner().getBounds().getCopy();
	conn.getSourceAnchor().getOwner().translateToAbsolute(bounds);
	conn.translateToRelative(bounds);
	return bounds;
	}


	/**
	* getTrunkLocation
	* Method to retrieve the trunk location in relative coordinates based on
	* current tree state.
	*
	* @param conn Connection being routed
	* @return Point that is the trunk location in relative coordinates.
	*/
	public Point getTrunkLocation(Connection conn) {
	Dimension vertex = getTrunkVertex();
	Point target = getTrunkOrientation().getEdge(getTargetAnchorRelativeBounds(conn));

	Point ptTrunkLoc = new Point(vertex.width, vertex.height);
	ptTrunkLoc = ptTrunkLoc.getTranslated(target);

	return ptTrunkLoc;
	}

	/**
	* setTrunkLocation
	* Setter method to set the trunk location. Translates the point into a relative
	* point from the target edge.
	*
	* @param conn Connection being routed
	* @param ptTrunkLoc Point that is the trunk location in relative coordinates.
	*/
	public void setTrunkLocation(Connection conn, Point ptTrunkLoc) {
	Point ptRelTrunkLoc = new Point(ptTrunkLoc);

	final Rectangle targetAnchorBounds = getTargetAnchorRelativeBounds(conn);

	// update orientation
	if (isTopDown(conn)) {
	if (ptTrunkLoc.y < targetAnchorBounds.getCenter().y)
	setTrunkOrientation(Orientation.TOP);
	else
	setTrunkOrientation(Orientation.BOTTOM);
	}
	else {
	if (ptTrunkLoc.x < targetAnchorBounds.getCenter().x)
	setTrunkOrientation(Orientation.LEFT);
	else
	setTrunkOrientation(Orientation.RIGHT);
	}

	Point target = getTrunkOrientation().getEdge(targetAnchorBounds);

	Dimension currentVertex = ptRelTrunkLoc.getDifference(target);
	setTrunkVertex(currentVertex);
	}

	/**
	* updateConstraint
	* Updates the constraint value for the connection based on the tree vertex
	*
	* @param conn Connection whose constraint is to be updated.
	*/
	protected void updateConstraint(Connection conn) {
	if (isUpdatingPeers())
	return;

	List bendpoints = (List)conn.getRoutingConstraint();
	if (bendpoints == null)
	bendpoints = new ArrayList(conn.getPoints().size());

	if (bendpoints != null) {
	Point sourceRefPoint = conn.getSourceAnchor().getReferencePoint();
	conn.translateToRelative(sourceRefPoint);

	Point targetRefPoint = conn.getTargetAnchor().getReferencePoint();
	conn.translateToRelative( targetRefPoint);

	Point ptTrunk = getTrunkLocation(conn);
	Point ptSource = getBranchRouter().getSourceLocation(conn, ptTrunk);

	bendpoints.clear();
	PointList pts = getBranchRouter().recreateBranch(conn, ptSource, ptTrunk);
	for (int i=0; i<pts.size(); i++) {
	Bendpoint bp = new AbsoluteBendpoint(pts.getPoint(i));
	bendpoints.add(bp);
	}
	}

	setUpdatingPeers(true);

	try {
	setConstraint(conn, bendpoints);
	conn.invalidate();
	conn.validate();
	}
	catch (Exception e) {
	Trace.catching(Draw2dPlugin.getInstance(), Draw2dDebugOptions.EXCEPTIONS_CATCHING, TreeRouter.class, "updateConstraint", //$NON-NLS-1$
	e);
	}
	finally {
	setUpdatingPeers(false);
	}
	}

	/**
	* getPointsFromConstraint
	* Utility method retrieve the PointList equivalent of the bendpoint constraint
	* set in the Connection.
	*
	* @param conn Connection to retrieve the constraint from.
	* @return PointList list of points that is the direct equivalent of the set constraint.
	*/
	public PointList getPointsFromConstraint(Connection conn) {
	List bendpoints = (List)conn.getRoutingConstraint();
	if (bendpoints == null)
	return new PointList();

	PointList points = new PointList(bendpoints.size());
	for (int i = 0; i < bendpoints.size(); i++) {
	Bendpoint bp = (Bendpoint) bendpoints.get(i);
	points.addPoint(bp.getLocation());
	}

	straightenPoints(points, MapModeUtil.getMapMode(conn).DPtoLP(3));
	return points;
	}

	/**
	* straightenPoints
	* This is a simpler version of the @see updateIfNotRectilinear that simply ensures
	* that the lines are horizontal or vertical without any intelligence in terms of
	* shortest distance around a rectangle.
	*
	* @param newLine PointList to check for rectilinear qualities and change if necessary.
	* @param tolerance int tolerance value by which points will be straightened in HiMetrics
	*/
	static protected void straightenPoints(PointList newLine, int tolerance) {
	for (int i=0; i<newLine.size()-1; i++) {
	Point ptCurrent = newLine.getPoint(i);
	Point ptNext = newLine.getPoint(i+1);

	int xDelta = Math.abs(ptNext.x - ptCurrent.x);
	int yDelta = Math.abs(ptNext.y - ptCurrent.y);

	if (xDelta < yDelta) {
	if (xDelta > tolerance)
	return;
	ptNext.x = ptCurrent.x;
	} else {
	if (yDelta > tolerance)
	return;
	ptNext.y = ptCurrent.y;
	}

	newLine.setPoint(ptNext, i+1);
	}
	}

	/**
	* Returns the branch router in the chain.
	* @return The getBranchRouter router
	*
	*/
	protected BranchRouter getBranchRouter() {
	return branchRouter;
	}

	/**
	* @see org.eclipse.draw2d.ConnectionRouter#remove(Connection)
	*/
	public void remove(Connection conn) {
	if (conn.getSourceAnchor() == null \|\| conn.getTargetAnchor() == null)
	return;

	int index = connectionList.indexOf(conn);
	connectionList.remove(conn);
	for (int i = index + 1; i < connectionList.size(); i++)
	((Connection)connectionList.get(i)).revalidate();

	getBranchRouter().remove(conn);
	}

	/**
	* isTopDown
	* Utility method to determine if the connection should routed in a top-down fashion
	* or in a horizontal fashion.
	*
	* @param conn Connection to query
	* @return boolean true if connection should be routed top-down, false otherwise.
	*/
	public boolean isTopDown(Connection conn) {
	boolean vertical = true;
	if (conn instanceof ITreeConnection) {
	vertical = ((ITreeConnection)conn).getOrientation().equals(ITreeConnection.Orientation.VERTICAL) ? vertical = true : false;
	}

	return vertical;
	}

	private int DEFAULT_TRUNK_HEIGHT = 32;

	/**
	* checkTrunkVertex
	* Method to initialize the trunk vertex to a default value if not already set
	*
	* @param conn Connection to be routed.
	*/
	private void checkTrunkVertex(Connection conn) {
	if (getTrunkVertex() == null) {
	Rectangle sourceRect = conn.getSourceAnchor().getOwner().getBounds();
	Rectangle targetRect = conn.getTargetAnchor().getOwner().getBounds();

	Dimension default_trunk = new Dimension(0, DEFAULT_TRUNK_HEIGHT);
	conn.translateToRelative(default_trunk);

	if (isTopDown(conn)) {
	if (sourceRect.getCenter().y < targetRect.getCenter().y) {
	setTrunkVertex(new Dimension(0, -default_trunk.height));
	setTrunkOrientation(Orientation.TOP);
	}
	else {
	setTrunkVertex(new Dimension(0, default_trunk.height));
	setTrunkOrientation(Orientation.BOTTOM);
	}
	}
	else {
	if (sourceRect.getCenter().x < targetRect.getCenter().x) {
	setTrunkVertex(new Dimension(-default_trunk.height, 0));
	setTrunkOrientation(Orientation.LEFT);
	}
	else {
	setTrunkVertex(new Dimension(default_trunk.height, 0));
	setTrunkOrientation(Orientation.RIGHT);
	}
	}
	}
	}

	/* (non-Javadoc)
	* Routes the given connection. Calls the 'getBranchRouter' router method first
	* @see org.eclipse.draw2d.ConnectionRouter#route(org.eclipse.draw2d.Connection)
	*/
	public void route(Connection conn) {

	if (conn.getSourceAnchor() == null \|\| conn.getSourceAnchor().getOwner() == null \|\|
	conn.getTargetAnchor() == null \|\| conn.getTargetAnchor().getOwner() == null) {
	super.route(conn);
	return;
	}

	if (!connectionList.contains(conn)) {
	connectionList.add(conn);
	}

	checkTrunkVertex(conn);

	getBranchRouter().route(conn);
	invalidate(conn);
	}

	/**
	* @return Returns the truckVertex.
	*/
	protected Dimension getTrunkVertex() {
	return trunkVertex;
	}

	/**
	* @param trunkVertex The trunkVertex to set.
	*/
	protected void setTrunkVertex(Dimension trunkVertex) {
	this.trunkVertex = trunkVertex;
	}

	/**
	* @return Returns the trunkOrientation.
	*/
	protected Orientation getTrunkOrientation() {
	return trunkOrientation;
	}

	/**
	* @param trunkOrientation The trunkOrientation to set.
	*/
	protected void setTrunkOrientation(Orientation trunkOrientation) {
	this.trunkOrientation = trunkOrientation;
	}

	/**
	* Utility method to determine if the given set of points conforms to the constraints
	* of being an orthogonal connection tree-branch.
	* 1. Points size must be 4.
	* 2. Source point resides with-in boundary of source shape based on orientation
	* 3. Target point resides with-in boundary of target shape based on orientation
	* 4. Middle line is perpendicular to the 2 end lines.
	*
	* @param conn the <code>Connection</code> to test
	* @param points <code>PointList</code> to test constraints against
	* @return <code>boolean</code> <code>true</code> if points represent valid orthogaonl tree
	* branch, <code>false</code> otherwise.
	*/
	public boolean isOrthogonalTreeBranch(Connection conn, PointList points) {
	if (isTreeBranch(conn, points)) {
	LineSeg branch = new LineSeg(points.getPoint(0), points.getPoint(1));
	LineSeg trunkShoulder = new LineSeg(points.getPoint(1), points.getPoint(2));
	LineSeg trunk = new LineSeg(points.getPoint(2), points.getPoint(3));

	if (isTopDown(conn))
	return branch.isVertical() && trunkShoulder.isHorizontal() && trunk.isVertical();
	else
	return branch.isHorizontal() && trunkShoulder.isVertical() && trunk.isHorizontal();
	}

	return false;
	}

	/**
	* Utility method to determine if the given set of points conforms to the constraints
	* of being a connection tree-branch.
	* 1. Points size must be 4.
	* 2. Source point resides with-in boundary of source shape based on orientation
	* 3. Target point resides with-in boundary of target shape based on orientation
	*
	* @param conn the <code>Connection</code> to test
	* @param points the <code>PointList</code> to test constraints against
	* @return <code>boolean</code> <code>true</code> if points represent valid tree branch,
	* <code>false</code> otherwise.
	*/
	public boolean isTreeBranch(Connection conn, PointList points) {
	if (points.size() == 4) {
	// just check if ends are with-in the owner bounding box
	Rectangle targetBounds = getTargetAnchorRelativeBounds(conn);
	Rectangle sourceBounds = getSourceAnchorRelativeBounds(conn);

	if (isTopDown(conn)) {
	return (points.getPoint(0).x > sourceBounds.x &&
	points.getPoint(0).x < sourceBounds.x + sourceBounds.width) &&
	(points.getPoint(3).x > targetBounds.x &&
	points.getPoint(3).x < targetBounds.x + targetBounds.width);
	}
	else
	{
	return (points.getPoint(0).y > sourceBounds.y &&
	points.getPoint(0).y < sourceBounds.y + sourceBounds.height) &&
	(points.getPoint(3).y > targetBounds.y &&
	points.getPoint(3).y < targetBounds.y + targetBounds.height);
	}
	}

	return false;
	}

	/**
	* @return Returns the connectionList List which is a copy of the internal list.
	*/
	public List getConnectionList() {
	return (List)connectionList.clone();
	}
	/**
	* @return Returns the updatingPeers.
	*/
	protected boolean isUpdatingPeers() {
	return updatingPeers;
	}
	/**
	* @param updatingPeers The updatingPeers to set.
	*/
	protected void setUpdatingPeers(boolean updatingPeers) {
	this.updatingPeers = updatingPeers;
	}
	}