EDIT

/*******************************************************************************

 * Copyright (c) 2004, 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.draw2d.graph;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import org.eclipse.draw2d.PositionConstants;

import org.eclipse.draw2d.geometry.Point;

import org.eclipse.draw2d.geometry.Rectangle;

/**

 * A vertex representation for the ShortestPathRouting. Vertices are either one

 * of four corners on an <code>Obstacle</code>(Rectangle), or one of the two end

 * points of a <code>Path</code>.

 * 

 * This class is not intended to be subclassed.

 * 

 * @author Whitney Sorenson

 * @since 3.0

 */

class Vertex extends Point {

	// constants for the vertex type

	static final int NOT_SET = 0;

	static final int INNIE = 1;

	static final int OUTIE = 2;

	// for shortest path

	List neighbors;

	boolean isPermanent = false;

	Vertex label;

	double cost = 0;

	// for routing

	int nearestObstacle = 0;

	double offset = 0;

	int type = NOT_SET;

	int count = 0;

	int totalCount = 0;

	Obstacle obs;

	List paths;

	boolean nearestObstacleChecked = false;

	Map cachedCosines;

	int positionOnObstacle = -1;

	private int origX, origY;

	/**

	 * Creates a new Vertex with the given x, y position and on the given

	 * obstacle.

	 * 

	 * @param x

	 *            x point

	 * @param y

	 *            y point

	 * @param obs

	 *            obstacle - can be null

	 */

	Vertex(int x, int y, Obstacle obs) {

		super(x, y);

		origX = x;

		origY = y;

		this.obs = obs;

	}

	/**

	 * Creates a new Vertex with the given point position and on the given

	 * obstacle.

	 * 

	 * @param p

	 *            the point

	 * @param obs

	 *            obstacle - can be null

	 */

	Vertex(Point p, Obstacle obs) {

		this(p.x, p.y, obs);

	}

	/**

	 * Adds a path to this vertex, calculates angle between two segments and

	 * caches it.

	 * 

	 * @param path

	 *            the path

	 * @param start

	 *            the segment to this vertex

	 * @param end

	 *            the segment away from this vertex

	 */

	void addPath(Path path, Segment start, Segment end) {

		if (paths == null) {

			paths = new ArrayList();

			cachedCosines = new HashMap();

		}

		if (!paths.contains(path))

			paths.add(path);

		cachedCosines.put(path, new Double(start.cosine(end)));

	}

	/**

	 * Creates a point that represents this vertex offset by the given amount

	 * times the offset.

	 * 

	 * @param modifier

	 *            the offset

	 * @return a Point that has been bent around this vertex

	 */

	Point bend(int modifier) {

		Point point = new Point(x, y);

		if ((positionOnObstacle & PositionConstants.NORTH) > 0)

			point.y -= modifier * offset;

		else

			point.y += modifier * offset;

		if ((positionOnObstacle & PositionConstants.EAST) > 0)

			point.x += modifier * offset;

		else

			point.x -= modifier * offset;

		return point;

	}

	/**

	 * Resets all fields on this Vertex.

	 */

	void fullReset() {

		totalCount = 0;

		type = NOT_SET;

		count = 0;

		cost = 0;

		offset = getSpacing();

		nearestObstacle = 0;

		label = null;

		nearestObstacleChecked = false;

		isPermanent = false;

		if (neighbors != null)

			neighbors.clear();

		if (cachedCosines != null)

			cachedCosines.clear();

		if (paths != null)

			paths.clear();

	}

	/**

	 * Returns a Rectangle that represents the region around this vertex that

	 * paths will be traveling in.

	 * 

	 * @param extraOffset

	 *            a buffer to add to the region.

	 * @return the rectangle

	 */

	Rectangle getDeformedRectangle(int extraOffset) {

		Rectangle rect = new Rectangle(0, 0, 0, 0);

		if ((positionOnObstacle & PositionConstants.NORTH) > 0) {

			rect.y = y - extraOffset;

			rect.height = origY - y + extraOffset;

		} else {

			rect.y = origY;

			rect.height = y - origY + extraOffset;

		}

		if ((positionOnObstacle & PositionConstants.EAST) > 0) {

			rect.x = origX;

			rect.width = x - origX + extraOffset;

		} else {

			rect.x = x - extraOffset;

			rect.width = origX - x + extraOffset;

		}

		return rect;

	}

	private int getSpacing() {

		if (obs == null)

			return 0;

		return obs.getSpacing();

	}

	/**

	 * Grows this vertex by its offset to its maximum size.

	 */

	void grow() {

		int modifier;

		if (nearestObstacle == 0)

			modifier = totalCount * getSpacing();

		else

			modifier = (nearestObstacle / 2) - 1;

		if ((positionOnObstacle & PositionConstants.NORTH) > 0)

			y -= modifier;

		else

			y += modifier;

		if ((positionOnObstacle & PositionConstants.EAST) > 0)

			x += modifier;

		else

			x -= modifier;

	}

	/**

	 * Shrinks this vertex to its original size.

	 */

	void shrink() {

		x = origX;

		y = origY;

	}

	/**

	 * Updates the offset of this vertex based on its shortest distance.

	 */

	void updateOffset() {

		if (nearestObstacle != 0)

			offset = ((nearestObstacle / 2) - 1) / totalCount;

	}

	/**

	 * @see org.eclipse.draw2d.geometry.Point#toString()

	 */

	public String toString() {

		return "V(" + origX + ", " + origY + ")"; //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$

	}

}