~ubuntu-branches/ubuntu/quantal/libjgraph-java/quantal

/*
 * @(#)EdgeView.java	1.0 03-JUL-04
 * 
 * Copyright (c) 2001-2004 Gaudenz Alder
 *  
 */
package org.jgraph.graph;

import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.Shape;
import java.awt.event.MouseEvent;
import java.awt.geom.AffineTransform;
import java.awt.geom.GeneralPath;
import java.awt.geom.Line2D;
import java.awt.geom.Point2D;
import java.awt.geom.Rectangle2D;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import javax.swing.SwingUtilities;

import org.jgraph.JGraph;
import org.jgraph.plaf.GraphUI;
import org.jgraph.plaf.basic.BasicGraphUI;

/**
 * The default implementation of an edge view. The getEdgeRenderer method
 * assumes a renderer of type EdgeRenderer. If you provide a custom renderer to
 * a subclass, you must also override the methods that call this method, namely:
 * getShape, getLabelBounds, getExtraLabelBounds, intersects and getBounds.
 * 
 * @version 1.0 1/1/02
 * @author Gaudenz Alder
 */

public class EdgeView extends AbstractCellView {

	/** Renderer for the class. */
	public static transient EdgeRenderer renderer = new EdgeRenderer();

	/** List of points of the edge. May contain ports. */
	protected List points;

	/** Cached source and target portview of the edge. */
	protected CellView source, target;

	protected CellView sourceParentView, targetParentView;

	/** Cached label position of the edge. */
	protected Point2D labelPosition;

	protected Point2D[] extraLabelPositions;

	protected transient Point2D labelVector = null;

	/** Drawing attributes that are created on the fly */
	public transient Shape beginShape, endShape, lineShape;

	/** Shared-path tune-up. */
	public transient GeneralPath sharedPath = null;

	protected transient Rectangle2D cachedBounds = null;

	/**
	 * Constructs an empty edge view.
	 */
	public EdgeView() {
		super();
	}

	/**
	 * Constructs an edge view for the specified model object.
	 * 
	 * @param cell
	 *            reference to the model object
	 */
	public EdgeView(Object cell) {
		super(cell);
	}

	//
	// Data Source
	//

	/**
	 * Overrides the parent method to udpate the cached points, source and
	 * target port. If the source or target is removed, a point is inserted into
	 * the array of points.
	 */
	public void refresh(GraphLayoutCache cache, CellMapper mapper,
			boolean createDependentViews) {
		// Makes sure the manual control points are passed to
		// the router instead of the cached control points after
		// changes to the edge (normally manual point changes).
		points = null;
		super.refresh(cache, mapper, createDependentViews);
		// Re-sync source- and targetportviews
		GraphModel model = cache.getModel();
		Object modelSource = model.getSource(cell);
		Object modelTarget = model.getTarget(cell);
		setSource(mapper.getMapping(modelSource, createDependentViews));
		setTarget(mapper.getMapping(modelTarget, createDependentViews));
		if (modelSource != null && getSource() == null)
			sourceParentView = getVisibleParent(model, mapper, modelSource);
		else
			sourceParentView = null;
		if (modelTarget != null && getTarget() == null)
			targetParentView = getVisibleParent(model, mapper, modelTarget);
		else
			targetParentView = null;
	}

	protected CellView getVisibleParent(GraphModel model, CellMapper mapper,
			Object port) {
		CellView view = null;
		do {
			view = mapper.getMapping(port, false);
			port = model.getParent(port);
		} while (view == null && port != null);
		return view;
	}

	/**
	 * Update attributes and recurse children.
	 */
	public void update(GraphLayoutCache cache) {
		super.update(cache);
		// Save the reference to the points so they can be changed
		// in-place by use of setPoint, setSource, setTarget methods.
		List controlPoints = GraphConstants.getPoints(allAttributes);
		if (controlPoints == null) {
			controlPoints = new ArrayList(4);
			controlPoints.add(allAttributes.createPoint(10, 10));
			controlPoints.add(allAttributes.createPoint(20, 20));
			GraphConstants.setPoints(allAttributes, controlPoints);
		}

		// Uses the manual control points while the edge is being routed.
		// Otherwise uses the cached points (eg. for preview).
		if (points == null)
			points = controlPoints;

		Edge.Routing routing = GraphConstants.getRouting(allAttributes);
		List routedPoints = null;
		// Passes the current cached points to the router
		if (routing != null)
			routedPoints = routing.route(cache, this);

		// Shadows the manual control points with the
		// routed control points
		points = (routedPoints != null && !routedPoints.isEmpty()) ? routedPoints
				: controlPoints;

		// Overrides manual point locations with the real port views
		if (points == controlPoints) {
			if (source != null)
				setSource(source);
			if (target != null)
				setTarget(target);
		}

		// Checks and caches label positions
		checkDefaultLabelPosition();
		Point2D[] positions = GraphConstants
				.getExtraLabelPositions(allAttributes);
		if (positions != null) {
			extraLabelPositions = new Point2D[positions.length];
			for (int i = 0; i < positions.length; i++)
				extraLabelPositions[i] = positions[i];
		} else
			extraLabelPositions = null;

		// Clear cached shapes
		beginShape = null;
		endShape = null;
		lineShape = null;
		invalidate();
	}

	/**
	 * Hook for subclassers to avoid default label positions.
	 */
	protected void checkDefaultLabelPosition() {
		labelPosition = GraphConstants.getLabelPosition(allAttributes);
		String label = String.valueOf(getCell());
		if (labelPosition == null && label != null && label.length() > 0) {
			int center = GraphConstants.PERMILLE / 2;
			labelPosition = new Point(center, 0);
			GraphConstants.setLabelPosition(allAttributes, labelPosition);
		}
	}

	/**
	 * Resets the cached values of the edge view
	 */
	protected void invalidate() {
		labelVector = null;
		sharedPath = null;
		cachedBounds = null;
	}

	/**
	 * Returns the shape of the view according to the last rendering state
	 */
	public Shape getShape() {
		if (sharedPath != null)
			return sharedPath;
		else {
			return sharedPath = (GeneralPath) getEdgeRenderer().createShape();
		}
	}

	//
	// View Methods
	//

	/**
	 * Returns true if this view intersects the given rectangle.
	 */
	public boolean intersects(JGraph graph, Rectangle2D rect) {
		boolean intersects = super.intersects(graph, rect);
		if (!isLeaf()) {
			return intersects;
		} else if (intersects) {
			Rectangle r = new Rectangle((int) rect.getX(), (int) rect.getY(),
					(int) rect.getWidth(), (int) rect.getHeight());
			return getEdgeRenderer().intersects(graph, this, r);
		}
		return false;
	}

	/**
	 * Returns the location for this edgeview.
	 */
	public Rectangle2D getBounds() {
		Rectangle2D rect = super.getBounds();
		if (rect == null) {
			if (cachedBounds == null) {
				cachedBounds = getEdgeRenderer().getBounds(this);
			}
			rect = cachedBounds;
		}
		return rect;
	}

	/**
	 * Returns the local renderer. Do not access the renderer field directly.
	 * Use this method instead. Note: This method is package private.
	 */
	EdgeRenderer getEdgeRenderer() {
		return (EdgeRenderer) getRenderer();
	}

	/**
	 * Returns a renderer for the class.
	 */
	public CellViewRenderer getRenderer() {
		return renderer;
	}

	/**
	 * Returns a cell handle for the view.
	 */
	public CellHandle getHandle(GraphContext context) {
		return new EdgeHandle(this, context);
	}

	//
	// Cached Values
	//

	/**
	 * Returns the CellView that represents the source of the edge.
	 */
	public CellView getSource() {
		return source;
	}

	public CellView getSourceParentView() {
		return sourceParentView;
	}

	/**
	 * Sets the <code>sourceView</code> of the edge.
	 */
	public void setSource(CellView sourceView) {
		sourceParentView = null;
		source = sourceView;
		if (source != null)
			points.set(0, source);
		else
			points.set(0, getPoint(0));
		invalidate();
	}

	/**
	 * Returns the CellView that represents the target of the edge.
	 */
	public CellView getTarget() {
		return target;
	}

	public CellView getTargetParentView() {
		return targetParentView;
	}

	/**
	 * Sets the <code>targetView</code> of the edge.
	 */
	public void setTarget(CellView targetView) {
		target = targetView;
		targetParentView = null;
		int n = points.size() - 1;
		if (target != null)
			points.set(n, target);
		else
			points.set(n, getPoint(n));
		invalidate();
	}

	/**
	 * Returns a point that describes the position of the label.
	 */
	public Point2D getExtraLabelPosition(int index) {
		return extraLabelPositions[index];
	}

	/**
	 * Returns a point that describes the position of the label.
	 */
	public Point2D getLabelPosition() {
		return labelPosition;
	}

	/**
	 * Sets the description of the label position.
	 */
	public void setLabelPosition(Point2D pos) {
		labelPosition.setLocation(pos);
		invalidate();
	}

	/**
	 * Sets the description of the label position.
	 */
	public void setExtraLabelPosition(int index, Point2D pos) {
		extraLabelPositions[index].setLocation(pos);
		invalidate();
	}

	//
	// Points
	//

	/**
	 * Returns true if the edge is a loop.
	 */
	public boolean isLoop() {
		return (getSource() != null && getSource() == getTarget())
				|| (sourceParentView != null && sourceParentView == targetParentView)
				|| (sourceParentView != null && getTarget() != null && getTarget()
						.getParentView() == sourceParentView)
				|| (targetParentView != null && getSource() != null && getSource()
						.getParentView() == targetParentView);
	}

	/**
	 * Returns the points.
	 * 
	 * @return List
	 */
	public List getPoints() {
		return points;
	}

	/**
	 * Returns the number of point for this edge.
	 */
	public int getPointCount() {
		if (points != null) {
			return points.size();
		} else {
			return 0;
		}
	}

	/**
	 * Returns the cached points for this edge.
	 */
	public Point2D getPoint(int index) {
		Object obj = points.get(index);
		if (index == 0 && sourceParentView != null) {
			return sourceParentView.getPerimeterPoint(this,
					getCenterPoint(sourceParentView),
					getNearestPoint(index == 0));
		} else if (index == getPointCount() - 1 && targetParentView != null) {
			return targetParentView.getPerimeterPoint(this,
					getCenterPoint(targetParentView),
					getNearestPoint(index == 0));
		} else if (obj instanceof PortView)
			// Port Location Seen From This Edge
			return ((PortView) obj).getLocation(this,
					getNearestPoint(index == 0));
		else if (obj instanceof CellView) {
			// Should not happen
			Rectangle2D r = ((CellView) obj).getBounds();
			return new Point2D.Double(r.getX(), r.getY());
		} else if (obj instanceof Point2D)
			// Regular Point
			return (Point2D) obj;
		return null;
	}

	/**
	 * Returns the nearest point wrt to the source or target. This method
	 * returns the next or previous point or port in the points list, eg. if
	 * source is true it returns the location of the point or port at index 1
	 * without calling the getLocation method on any ports.<br>
	 * Likewise, the method returns the location at index getPointCount()-2 if
	 * source is false.
	 */
	protected Point2D getNearestPoint(boolean source) {
		if (getPointCount() == 2) {
			if (source
					&& target instanceof PortView
					&& GraphConstants.getOffset(target.getAllAttributes()) != null) {
				return ((PortView) target).getLocation(this);
			}
			if (!source
					&& this.source instanceof PortView
					&& GraphConstants.getOffset(this.source.getAllAttributes()) != null) {
				return ((PortView) this.source).getLocation(this);
			}
			if (source && targetParentView != null && targetParentView.isLeaf())
				return getCenterPoint(targetParentView);
			else if (!source && sourceParentView != null
					&& sourceParentView.isLeaf())
				return getCenterPoint(sourceParentView);
		}
		return getPointLocation((source) ? 1 : getPointCount() - 2);
	}

	/**
	 * Returns the point of <code>edge</code> at <code>index</code>. Avoids
	 * calling <code>getLocation</code> on any ports of <code>edge</code>.
	 * <br>
	 * This is used from within getPoint to pass the nearest point to the
	 * portview to find it's location. This uses the center point of the parent
	 * view to determine the port view's location to avoid infinite recursion.
	 */
	protected Point2D getPointLocation(int index) {
		Object obj = points.get(index);
		if (obj instanceof Point2D)
			return (Point2D) obj;
		else if (obj instanceof PortView) {
			CellView vertex = ((CellView) obj).getParentView();
			if (vertex != null)
				return getCenterPoint(vertex);
		}
		return null;
	}

	/**
	 * Sets the point at <code>index</code> to <code>p</code>.
	 */
	public void setPoint(int index, Point2D p) {
		points.set(index, p);
		invalidate();
	}

	/**
	 * Adds <code>p</code> at position <code>index</code>.
	 */
	public void addPoint(int index, Point2D p) {
		points.add(index, p);
		invalidate();
	}

	/**
	 * Removes the point at position <code>index</code>.
	 */
	public void removePoint(int index) {
		points.remove(index);
		invalidate();
	}

	/**
	 * Adds an extra label.
	 */
	public void addExtraLabel(Point2D location, Object label) {
		Object[] extraLabels = GraphConstants
				.getExtraLabels(getAllAttributes());
		Point2D[] positions = GraphConstants
				.getExtraLabelPositions(getAllAttributes());

		// Inserts a new extra label
		if (extraLabels == null) {
			extraLabels = new Object[1];
			positions = new Point2D[1];
		} else {
			Object[] tmp = new Object[extraLabels.length + 1];
			System.arraycopy(extraLabels, 0, tmp, 0, extraLabels.length);
			extraLabels = tmp;
			Point2D[] pts = new Point2D[positions.length + 1];
			System.arraycopy(positions, 0, pts, 0, positions.length);
			positions = pts;
		}
		int newIndex = extraLabels.length - 1;
		extraLabels[newIndex] = label;
		positions[newIndex] = location;
		GraphConstants.setExtraLabels(getAllAttributes(), extraLabels);
		GraphConstants.setExtraLabelPositions(getAllAttributes(), positions);
	}

	/**
	 * Removes the point at position <code>index</code>.
	 */
	public void removeExtraLabel(int index) {
		Object[] labels = GraphConstants.getExtraLabels(getAllAttributes());
		Point2D[] pts = GraphConstants
				.getExtraLabelPositions(getAllAttributes());
		if (labels == null || labels.length > 1) {
			Object[] newLabels = new Object[labels.length - 1];
			Point2D[] newPts = new Point2D[pts.length - 1];
			System.arraycopy(labels, 0, newLabels, 0, index);
			if (index < newLabels.length)
				System.arraycopy(labels, index + 1, newLabels, index,
						newLabels.length - index);
			System.arraycopy(pts, 0, newPts, 0, index);
			if (index < newPts.length)
				System.arraycopy(pts, index + 1, newPts, index, newPts.length
						- index);
			GraphConstants.setExtraLabels(getAllAttributes(), newLabels);
			GraphConstants.setExtraLabelPositions(getAllAttributes(), newPts);
		} else {
			// TODO: Remove via REMOVEATTRIBUTES
			GraphConstants.setExtraLabels(getAllAttributes(), new Object[0]);
			GraphConstants.setExtraLabelPositions(getAllAttributes(),
					new Point2D[0]);
		}
	}

	/**
	 * Hook to return the vector that is taken as the base vector to compute
	 * relative label positions. Normally, the vector goes from the first to the
	 * last point on the edge, unless these points are equal, in which case the
	 * average distance of all points to the source point is used.
	 */
	public Point2D getLabelVector() {
		if (labelVector == null) {
			Point2D p0 = getPoint(0);
			double dx = 0;
			double dy = 0;
			// Finds an average distance
			dx = 0;
			dy = 0;
			int n = getPointCount();
			if (isLoop()) {
				for (int i = 1; i < n; i++) {
					Point2D point = getPoint(i);
					dx += point.getX() - p0.getX();
					dy += point.getY() - p0.getY();
				}
				n /= 2;
				dx /= n;
				dy /= n;
				labelVector = new Point2D.Double(dx, dy);
			} else {
				Point2D point = getPoint(n - 1);
				dx += point.getX() - p0.getX();
				dy += point.getY() - p0.getY();
				labelVector = new Point2D.Double(dx, dy);
			}
		}
		return labelVector;
	}

	/**
	 * Returns the absolute position of the main label
	 * @return the absolute position of the main label
	 */
	protected Point2D getAbsoluteLabelPosition() {
		Point2D result = getAbsoluteLabelPositionFromRelative(GraphConstants.getLabelPosition(getAllAttributes()));
		return result;
	}
	
	/**
	 * Returns the absolute position of the specified extra label
	 * @param index the index of the extra label
	 * @return the absolute position of the specified extra label
	 */
	protected Point2D getAbsoluteExtraLabelPosition(int index) {
		Point2D[] positions = GraphConstants
				.getExtraLabelPositions(getAllAttributes());
		if (positions != null && positions.length > index) {
			Point2D result = getAbsoluteLabelPositionFromRelative(positions[index]);
			return result;
		}
		return null;
	}
	
	/**
	 * Converts relative label position to absolute and allows for
	 * any label offset.
	 * @param geometry the relative label position
	 * @return the absolute label position including any offset
	 */
	protected Point2D getAbsoluteLabelPositionFromRelative(Point2D geometry) {
		Point2D result = convertRelativeLabelPositionToAbsolute(geometry);
		
		if (result != null)
		{
			double offsetX = 0;
			double offsetY = 0;

			Point2D offset = GraphConstants.getOffset(getAllAttributes());

			if (offset != null) {
				offsetX = offset.getX();
				offsetY = offset.getY();
			}

			double x = result.getX() + offsetX;
			double y = result.getY() + offsetY;
			return new Point2D.Double(x, y);
		}
		
		return null;
	}
	
	/**
	 * Converts an relative label position (x is distance along edge and y is
	 * distance above/below edge vector) into an absolute co-ordination point
	 * @param geometry the relative label position
	 * @return the absolute label position
	 */
	protected Point2D convertRelativeLabelPositionToAbsolute(Point2D geometry) {
		int pointCount = getPointCount();
		
		double length = 0;
		double[] segments = new double[pointCount];
		Point2D pt = getPoint(0);
		
		if (pt != null)
		{
			// Find the total length of the segments and also store the length
			// of each segment
			for (int i = 1; i < pointCount; i++)
			{
				Point2D tmp = getPoint(i);
				
				if (tmp != null)
				{
					double dx = pt.getX() - tmp.getX();
					double dy = pt.getY() - tmp.getY();

					double segment = Math.sqrt(dx * dx + dy * dy);
					
					segments[i - 1] = segment;
					length += segment;
					pt = tmp;
				}
			}

			// Change x to be a value between 0 and 1 indicating how far
			// along the edge the label is
			double x = geometry.getX()/GraphConstants.PERMILLE;
			double y = geometry.getY();
			
			// dist is the distance along the edge the label is
			double dist = x * length;
			length = 0;
			
			int index = 1;
			double segment = segments[0];

			// Find the length up to the start of the segment the label is
			// on (length) and retrieve the length of that segment (segment)
			while (dist > length + segment && index < pointCount - 1)
			{
				length += segment;
				segment = segments[index++];
			}

			// factor is the proportion along this segment the label lies at
			double factor = (dist - length) / segment;
			
			Point2D p0 = getPoint(index - 1);
			Point2D pe = getPoint(index);

			if (p0 != null && pe != null)
			{
				// The x and y offsets of the label from the start point
				// of the segment
				double dx = pe.getX() - p0.getX();
				double dy = pe.getY() - p0.getY();
				
				// The normal vectors of
				double nx = dy / segment;
				double ny = dx / segment;
				
				// The x position is the start x of the segment + the factor of
				// the x offset between the start and end of the segment + the
				// x component of the y (height) offset contributed along the
				// normal vector.
				x = p0.getX() + dx * factor - nx * y;

				// The x position is the start y of the segment + the factor of
				// the y offset between the start and end of the segment + the
				// y component of the y (height) offset contributed along the
				// normal vector.
				y = p0.getY() + dy * factor + ny * y;
				return new Point2D.Double(x, y);
			}
		}
		
		return null;
	}

	//
	// Routing
	//

	public static double getLength(CellView view) {
		double cost = 1;
		if (view instanceof EdgeView) {
			EdgeView edge = (EdgeView) view;
			Point2D last = null, current = null;
			for (int i = 0; i < edge.getPointCount(); i++) {
				current = edge.getPoint(i);
				if (last != null)
					cost += last.distance(current);
				last = current;
			}
		}
		return cost;
	}

	//
	// Handle
	//

	// This implementation uses the point instance to make the change. No index
	// is used for the current point because routing could change the index
	// during
	// the move operation.
	public static class EdgeHandle implements CellHandle, Serializable {

		protected JGraph graph;

		/* Pointer to the edge and its clone. */
		protected EdgeView edge, orig;

		/*
		 * Boolean indicating whether the source, target or label is being
		 * edited.
		 */
		protected boolean label = false, source = false, target = false;

		/**
		 * Holds the index of the current (editing) label or point.
		 */
		protected int currentLabel = -1, currentIndex = -1;

		/* Pointer to the currently selected point. */
		protected Point2D currentPoint;

		/* Array of control points represented as rectangles. */
		protected transient Rectangle2D[] r;

		/* A control point for the label position. */
		protected transient Rectangle2D loc;

		protected transient Rectangle2D[] extraLabelLocations;

		protected boolean firstOverlayCall = true;

		protected boolean isEdgeConnectable = true;

		protected EdgeView relevantEdge = null;

		/**
		 * True if the cell is being edited.
		 */
		protected boolean editing = false;

		/**
		 * Holds the initial location of the label.
		 */
		protected Point2D initialLabelLocation = null;

		/**
		 * Indicates whether the edge has been modified during the last mouse
		 * pressed and dragged operations.
		 */
		protected boolean edgeModified = false;

		public EdgeHandle(EdgeView edge, GraphContext ctx) {
			this.graph = ctx.getGraph();
			this.edge = edge;
			editing = graph.getEditingCell() == edge.getCell();
			loc = new Rectangle();
			Object[] labels = GraphConstants.getExtraLabels(edge
					.getAllAttributes());
			if (labels != null) {
				extraLabelLocations = new Rectangle[labels.length];
				for (int i = 0; i < extraLabelLocations.length; i++)
					extraLabelLocations[i] = new Rectangle();
			}
			orig = (EdgeView) graph.getGraphLayoutCache().getMapping(
					edge.getCell(), false);
			reloadPoints(orig);
			isEdgeConnectable = GraphConstants.isConnectable(edge
					.getAllAttributes());
		}

		protected void reloadPoints(EdgeView edge) {
			relevantEdge = edge;
			r = new Rectangle[edge.getPointCount()];
			for (int i = 0; i < r.length; i++)
				r[i] = new Rectangle();
			invalidate();
		}

		// Update and paint control points
		public void paint(Graphics g) {
			invalidate();
			if (!edge.isLeaf())
				return;
			for (int i = 0; i < r.length; i++) {
				if (isEdgeConnectable && !editing)
					g.setColor(graph.getHandleColor());
				else
					g.setColor(graph.getLockedHandleColor());
				g.fill3DRect((int) r[i].getX(), (int) r[i].getY(), (int) r[i]
						.getWidth(), (int) r[i].getHeight(), true);
				CellView port = null;
				if (i == 0 && edge.getSource() != null)
					port = edge.getSource();
				else if (i == r.length - 1 && edge.getTarget() != null)
					port = edge.getTarget();
				if (port != null
						|| (i == 0 && edge.getSourceParentView() != null)
						|| (i == r.length - 1 && edge.getTargetParentView() != null)) {
					g.setColor(graph.getLockedHandleColor());
					Point2D tmp = (port != null) ? GraphConstants
							.getOffset(port.getAllAttributes()) : null;
					if (tmp != null) {
						g.drawLine((int) r[i].getX() + 1,
								(int) r[i].getY() + 1,
								(int) (r[i].getX() + r[i].getWidth()) - 3,
								(int) (r[i].getY() + r[i].getHeight()) - 3);
						g.drawLine((int) r[i].getX() + 1,
								(int) (r[i].getY() + r[i].getHeight()) - 3,
								(int) (r[i].getX() + r[i].getWidth()) - 3,
								(int) r[i].getY() + 1);
					} else
						g.drawRect((int) r[i].getX() + 2,
								(int) r[i].getY() + 2,
								(int) r[i].getWidth() - 5, (int) r[i]
										.getHeight() - 5);
				}
			}
			if (!graph.isXorEnabled()) {
				firstOverlayCall = false;
				overlay(g);
			}
		}

		public void overlay(Graphics g) {
			if (edge != null && !firstOverlayCall && edge.isLeaf()) {
				// g.setColor(graph.getBackground()); // JDK 1.3
				g.setColor(graph.getForeground());
				if (graph.isXorEnabled()) {
					g.setXORMode(graph.getBackground().darker());
				}
				Graphics2D g2 = (Graphics2D) g;
				AffineTransform oldTransform = g2.getTransform();
				g2.scale(graph.getScale(), graph.getScale());
				graph.getUI().paintCell(g, edge, edge.getBounds(), true);
				g2.setTransform(oldTransform);
				if (isSourceEditing() && edge.getSource() != null)
					paintPort(g, edge.getSource());
				else if (isTargetEditing() && edge.getTarget() != null)
					paintPort(g, edge.getTarget());
			}
			firstOverlayCall = false;
		}

		protected void paintPort(Graphics g, CellView p) {
			boolean offset = (GraphConstants.getOffset(p.getAllAttributes()) != null);
			Rectangle2D r = (offset) ? p.getBounds() : p.getParentView()
					.getBounds();
			r = graph.toScreen((Rectangle2D) r.clone());
			int s = 3;
			r.setFrame(r.getX() - s, r.getY() - s, r.getWidth() + 2 * s, r
					.getHeight()
					+ 2 * s);
			graph.getUI().paintCell(g, p, r, true);
		}

		protected boolean snap(boolean source, Point2D point) {
			boolean connect = graph.isConnectable() && isEdgeConnectable;
			Object port = graph.getPortForLocation(point.getX(), point.getY());
			if (port != null
					&& graph.getModel().getParent(port) == edge.getCell())
				port = null;
			if (port != null && connect) {
				CellView portView = graph.getGraphLayoutCache().getMapping(
						port, false);
				Rectangle2D dirty = edge.getBounds();
				dirty.add(portView.getParentView().getBounds());
				if (GraphConstants.isConnectable(portView.getParentView()
						.getAllAttributes())) {
					Object cell = edge.getCell();
					if (source && graph.getModel().acceptsSource(cell, port)) {
						if (edge.getSource() != portView) {
							edgeModified = true;
							if (graph.isXorEnabled()) {
								overlay(graph.getGraphics());
							}
							edge.setSource(portView);
							edge.update(graph.getGraphLayoutCache());
							if (graph.isXorEnabled()) {
								overlay(graph.getGraphics());
							} else {
								dirty.add(edge.getBounds());
								graph.repaint((int) dirty.getX(), (int) dirty
										.getY(), (int) dirty.getWidth(),
										(int) dirty.getHeight());
							}
						}
						return true;
					} else if (!source
							&& graph.getModel().acceptsTarget(cell, port)) {
						if (edge.getTarget() != portView) {
							edgeModified = true;
							if (graph.isXorEnabled()) {
								overlay(graph.getGraphics());
							}
							edge.setTarget(portView);
							edge.update(graph.getGraphLayoutCache());
							if (graph.isXorEnabled()) {
								overlay(graph.getGraphics());
							} else {
								dirty.add(edge.getBounds());
								graph.repaint((int) dirty.getX(), (int) dirty
										.getY(), (int) dirty.getWidth(),
										(int) dirty.getHeight());
							}
						}
						return true;
					}
				}
			}
			return false;
		}

		public boolean isConstrainedMoveEvent(MouseEvent e) {
			GraphUI ui = graph.getUI();
			if (ui instanceof BasicGraphUI)
				return ((BasicGraphUI) ui).isConstrainedMoveEvent(e);
			return false;
		}

		/**
		 * Returning true signifies a mouse event adds a new point to an edge.
		 */
		public boolean isAddPointEvent(MouseEvent event) {
			return event.isPopupTrigger()
					|| SwingUtilities.isRightMouseButton(event);
		}

		/**
		 * Returning true signifies a mouse event removes a given point.
		 */
		public boolean isRemovePointEvent(MouseEvent event) {
			return event.isPopupTrigger()
					|| SwingUtilities.isRightMouseButton(event);
		}

		protected boolean isSourceEditing() {
			return source;
		}

		protected boolean isTargetEditing() {
			return target;
		}

		/*
		 * Returns true if either the source, target, label or a point is being
		 * edited.
		 */
		protected boolean isEditing() {
			return source || target || label || currentLabel >= 0
					|| currentPoint != null;
		}

		/**
		 * Invoked when the mouse pointer has been moved on a component (with no
		 * buttons down).
		 */
		public void mouseMoved(MouseEvent event) {
			for (int i = 0; i < r.length; i++)
				if (r[i].contains(event.getPoint())) {
					graph.setCursor(new Cursor(Cursor.CROSSHAIR_CURSOR));
					event.consume();
					return;
				}
			if (loc.contains(event.getPoint()) && graph.isMoveable()
					&& GraphConstants.isMoveable(edge.getAllAttributes())) {
				graph.setCursor(new Cursor(Cursor.HAND_CURSOR));
				event.consume();
			}
			if (extraLabelLocations != null && graph.isMoveable()
					&& GraphConstants.isMoveable(edge.getAllAttributes())) {
				for (int i = 0; i < extraLabelLocations.length; i++) {
					if (extraLabelLocations[i].contains(event.getPoint())) {
						graph.setCursor(new Cursor(Cursor.HAND_CURSOR));
						event.consume();
					}
				}
			}
		}

		// Handle mouse pressed event.
		public void mousePressed(MouseEvent event) {
			/* INV: currentPoint = null; source = target = label = false; */
			if (!edge.isLeaf())
				return;
			boolean bendable = graph.isBendable()
					&& GraphConstants.isBendable(edge.getAllAttributes());
			int x = event.getX();
			int y = event.getY();
			// Detect hit on control point
			int index = 0;
			for (index = 0; index < r.length; index++) {
				if (r[index].contains(x, y)) {
					currentPoint = edge.getPoint(index);
					currentIndex = index;
					source = index == 0;
					target = index == r.length - 1;
					break;
				}
			}
			// Detect hit on label
			if (!isEditing() && graph.isMoveable()
					&& GraphConstants.isMoveable(edge.getAllAttributes())
					&& loc != null && loc.contains(x, y)
					&& !isAddPointEvent(event) && !isRemovePointEvent(event)
					&& graph.getEdgeLabelsMovable()) {
				initialLabelLocation = (Point2D) edge.getLabelPosition()
						.clone();
				label = true;
			}
			// Detect hit on extra labels
			else if (extraLabelLocations != null && !isEditing()
					&& graph.isMoveable() && graph.getEdgeLabelsMovable()
					&& GraphConstants.isMoveable(edge.getAllAttributes())) {
				for (int i = 0; i < extraLabelLocations.length; i++) {
					if (extraLabelLocations[i] != null
							&& extraLabelLocations[i].contains(x, y)) {
						currentLabel = i;
						initialLabelLocation = (Point2D) edge
								.getExtraLabelPosition(currentLabel).clone();
						if (isRemovePointEvent(event)) {
							edge.removeExtraLabel(i);
							edgeModified = true;
							mouseReleased(event);
						}
						break;
					}
				}
			}
			// Remove Point
			if (isRemovePointEvent(event)
					&& currentPoint != null
					&& !source
					&& !target
					&& bendable
					&& (edge.getSource() == null || currentIndex > 0)
					&& (edge.getTarget() == null || currentIndex < edge
							.getPointCount() - 1)) {
				edge.removePoint(index);
				edgeModified = true;
				mouseReleased(event);
				// Add Point
			} else if (isAddPointEvent(event) && !isEditing() && bendable) {
				int s = graph.getHandleSize();
				Rectangle2D rect = graph.fromScreen(new Rectangle(x - s, y - s,
						2 * s, 2 * s));
				if (edge.intersects(graph, rect)) {
					Point2D point = graph.fromScreen(graph.snap(new Point(event
							.getPoint())));
					double min = Double.MAX_VALUE, dist = 0;
					for (int i = 0; i < edge.getPointCount() - 1; i++) {
						Point2D p = edge.getPoint(i);
						Point2D p1 = edge.getPoint(i + 1);
						dist = new Line2D.Double(p, p1).ptSegDistSq(point);
						if (dist < min) {
							min = dist;
							index = i + 1;
						}
					}
					edge.addPoint(index, point);
					edgeModified = true;
					currentPoint = point;
					reloadPoints(edge);
					paint(graph.getGraphics());
				}
			}
			if (isEditing())
				event.consume();
		}

		public void mouseDragged(MouseEvent event) {
			Point2D p = graph.fromScreen(new Point(event.getPoint()));
			// Move Label
			if (label || currentLabel >= 0) {
				Rectangle2D r = edge.getBounds();
				if (r != null) {
					edgeModified = true;
					if (graph.isXorEnabled()) {
						overlay(graph.getGraphics());
					}
					if (!GraphConstants.isLabelAlongEdge(edge.getAllAttributes())) {
						p = getRelativeLabelPosition(edge, p);
					} else {
						double x = p.getX();
						double y = p.getY();

						Point2D p0 = edge.getPoint(0);

						double p0x = p0.getX();
						double p0y = p0.getY();

						Point2D vector = edge.getLabelVector();
						double dx = vector.getX();
						double dy = vector.getY();

						double pex = p0.getX() + dx;
						double pey = p0.getY() + dy;

						double len = Math.sqrt(dx * dx + dy * dy);
						if (len > 0) {
							double u = GraphConstants.PERMILLE;
							double posy = len
									* (-y * dx + p0y * dx + x * dy - p0x * dy)
									/ (-pey * dy + p0y * dy - dx * pex + dx * p0x);
							double posx = u
									* (-y * pey + y * p0y + p0y * pey - p0y * p0y
											- pex * x + pex * p0x + p0x * x - p0x
											* p0x)
									/ (-pey * dy + p0y * dy - dx * pex + dx * p0x);
							p = new Point2D.Double(posx, posy);
						} else {
							p = new Point2D.Double(x - p0.getX(), y - p0.getY());
						}
					}
					Rectangle2D dirty = edge.getBounds();
					if (label) {
						edge.setLabelPosition(p);
					} else {
						edge.setExtraLabelPosition(currentLabel, p);
					}
					edge.update(graph.getGraphLayoutCache());
					if (graph.isXorEnabled()) {
						overlay(graph.getGraphics());
					} else {
						graph.repaint((int) dirty.getX(), (int) dirty
								.getY(), (int) dirty.getWidth(),
								(int) dirty.getHeight());
					}
				}
			} else if (isEditing() && currentPoint != null) {
				boolean disconnectable = (!source && !target)
						|| (graph.isDisconnectable() && GraphConstants
								.isDisconnectable(orig.getAllAttributes()));
				if (source)
					disconnectable = disconnectable
							&& ((orig.getSource() == null && orig
									.getSourceParentView() == null)
									|| (orig.getSource() != null && GraphConstants
											.isDisconnectable(orig.getSource()
													.getParentView()
													.getAllAttributes())) || (orig
									.getSourceParentView() != null && GraphConstants
									.isDisconnectable(orig
											.getSourceParentView()
											.getAllAttributes())));
				if (target)
					disconnectable = disconnectable
							&& ((orig.getTarget() == null && orig
									.getTargetParentView() == null)
									|| (orig.getTarget() != null && GraphConstants
											.isDisconnectable(orig.getTarget()
													.getParentView()
													.getAllAttributes())) || (orig
									.getTargetParentView() != null && GraphConstants
									.isDisconnectable(orig
											.getTargetParentView()
											.getAllAttributes())));
				// Find Source/Target Port
				if (!((source && snap(true, event.getPoint())) || (target && snap(
						false, event.getPoint())))
						&& disconnectable) {
					// Else Use Point
					boolean acceptSource = source
							&& (graph.getModel().acceptsSource(edge.getCell(),
									null) || graph.isPreviewInvalidNullPorts());
					boolean acceptTarget = target
							&& (graph.getModel().acceptsTarget(edge.getCell(),
									null) || graph.isPreviewInvalidNullPorts());
					if (acceptSource || acceptTarget || !(source || target)) {
						edgeModified = true;
						Rectangle2D dirty = edge.getBounds();
						if (edge.getSource() != null) {
							dirty.add(edge.getSource().getParentView()
									.getBounds());
						}
						if (edge.getTarget() != null) {
							dirty.add(edge.getTarget().getParentView()
									.getBounds());
						}
						if (graph.isXorEnabled()) {
							overlay(graph.getGraphics());
						}
						p = graph.fromScreen(graph.snap(new Point(event
								.getPoint())));
						// Constrained movement
						if (isConstrainedMoveEvent(event) && currentIndex >= 0) {
							// Reset Initial Positions
							EdgeView orig = (EdgeView) graph
									.getGraphLayoutCache().getMapping(
											edge.getCell(), false);
							Point2D origPoint = orig.getPoint(currentIndex);
							double totDx = p.getX() - origPoint.getX();
							double totDy = p.getY() - origPoint.getY();
							if (Math.abs(totDx) < Math.abs(totDy))
								p.setLocation(origPoint.getX(), p.getY());
							else
								p.setLocation(p.getX(), origPoint.getY());
						}
						// Do not move into negative space
						p.setLocation(Math.max(0, p.getX()), Math.max(0, p
								.getY()));
						currentPoint.setLocation(p);
						if (source) {
							edge.setPoint(0, p);
							edge.setSource(null);
						} else if (target) {
							edge.setPoint(edge.getPointCount() - 1, p);
							edge.setTarget(null);
						}
						edge.update(graph.getGraphLayoutCache());
						dirty.add(edge.getBounds());
						if (graph.isXorEnabled()) {
							overlay(graph.getGraphics());
						} else {
							if (edge.getSource() != null) {
								dirty.add(edge.getSource().getParentView()
										.getBounds());
							}
							if (edge.getTarget() != null) {
								dirty.add(edge.getTarget().getParentView()
										.getBounds());
							}
							graph.repaint((int) dirty.getX(), (int) dirty
									.getY(), (int) dirty.getWidth(),
									(int) dirty.getHeight());
						}
					}
				}
			}
		}
		
		protected Point2D getRelativeLabelPosition(EdgeView edge, Point2D p) {
			int pointCount = edge.getPointCount();
			
			double totalLength = 0;
			double[] segments = new double[pointCount];
			
			Point2D p0 = edge.getPoint(0);
			Point2D pt = p0;
			
			// Calculate the total length of the edge
			for (int i = 1; i < pointCount; i++)
			{
				Point2D tmp = edge.getPoint(i);
				
				if (tmp != null)
				{
					double dx = pt.getX() - tmp.getX();
					double dy = pt.getY() - tmp.getY();

					double segment = Math.sqrt(dx * dx + dy * dy);
					
					segments[i - 1] = segment;
					totalLength += segment;
					pt = tmp;
				}
			}
			
			// Work which line segment the point of the label is closest to
			Point2D last = edge.getPoint(1);
			Line2D line = new Line2D.Double(p0, last);
			double minDist = line.ptSegDistSq(p);
			
			int index = 0;
			double tmp = 0;
			double length = 0;
			
			for (int i = 2; i < pointCount; i++)
			{
				tmp += segments[i-2];
				
				line = new Line2D.Double(edge.getPoint(i), last);
				double dist = line.ptSegDistSq(p);
				
				if (dist < minDist) {
					minDist = dist;
					index = i-1;
					length = tmp;
				}
				
				last = edge.getPoint(i);
			}
			
			double seg = segments[index];
			
			pt = edge.getPoint(index);
			
			double x2 = pt.getX();
			double y2 = pt.getY();
			
			Point2D pt2 = edge.getPoint(index+1);
			
			double x1 = pt2.getX();
			double y1 = pt2.getY();
			
			double px = p.getX();
			double py = p.getY();
			
			double xSegment = x2 - x1;
			double ySegment = y2 - y1;
	
			px -= x1;
			py -= y1;
	
			double projlenSq = 0;
	
		    px = xSegment - px;
		    py = ySegment - py;
		    double dotprod = px * xSegment + py * ySegment;

		    if (dotprod <= 0.0)
		    {
				projlenSq = 0;
		    }
		    else
		    {
				projlenSq = dotprod * dotprod / (xSegment * xSegment + ySegment * ySegment);
		    }

		    double projlen = Math.sqrt(projlenSq);
			if (projlen > seg)
			{
				projlen = seg;						
			}

			double yDistance = Line2D.ptLineDist(pt2.getX(), pt2.getY(), pt.getX(), pt.getY(), p.getX(), p.getY());
			int direction = Line2D.relativeCCW(pt2.getX(), pt2.getY(), pt.getX(), pt.getY(), p.getX(), p.getY());
			
			if (direction == -1) {
				yDistance = -yDistance;
			}
			
			// Constructs the relative point for the label
			Point2D result = new Point2D.Double(((((totalLength/2 - length - projlen)/
					totalLength)*-2)+1)*GraphConstants.PERMILLE / 2, yDistance);
			
			// Use the utility method to find 
			Point2D storedRelativePosition = edge.convertRelativeLabelPositionToAbsolute(result);
			if (p.equals(storedRelativePosition)) {
				GraphConstants.setRemoveAttributes(edge.getAllAttributes(), new Object[] {GraphConstants.OFFSET});
			} else {
				Point2D off = new Point2D.Double(p.getX() - storedRelativePosition.getX(), p.getY() - storedRelativePosition.getY());
				GraphConstants.setOffset(edge.getAllAttributes(), off);
			}
			return result;
		}

		// Handle mouse released event
		public void mouseReleased(MouseEvent e) {
			boolean clone = e.isControlDown() && graph.isCloneable();
			GraphModel model = graph.getModel();
			Object source = (edge.getSource() != null) ? edge.getSource()
					.getCell() : null;
			Object target = (edge.getTarget() != null) ? edge.getTarget()
					.getCell() : null;
			if (edgeModified && model.acceptsSource(edge.getCell(), source)
					&& model.acceptsTarget(edge.getCell(), target)) {

				// Creates an extra label if the label was cloned
				if (clone && initialLabelLocation != null) {

					// Resets the dragging label position and adds a new label
					// instead. Note: label locations are modified in-place
					// which is why we need to clone at beginning.
					Object value = null;
					Point2D location = null;
					Object[] extraLabels = GraphConstants.getExtraLabels(edge
							.getAllAttributes());
					if (label) {
						location = (Point2D) edge.getLabelPosition().clone();
						value = graph.convertValueToString(orig);
						edge.setLabelPosition(initialLabelLocation);
					} else {
						location = (Point2D) edge.getExtraLabelPosition(
								currentLabel).clone();
						value = extraLabels[currentLabel];
						edge.setExtraLabelPosition(currentLabel,
								initialLabelLocation);
					}
					edge.addExtraLabel(location, value);
					edge.update(graph.getGraphLayoutCache());
					clone = false;
				}

				// Creates the data required for the edit/insert call
				ConnectionSet cs = createConnectionSet(edge, clone);
				Map nested = GraphConstants.createAttributes(
						new CellView[] { edge }, null);

				// The cached points may be different from what's
				// in the attribute map if the edge is routed.
				Map tmp = (Map) nested.get(edge.getCell());
				List controlPoints = GraphConstants.getPoints(tmp);
				List currentPoints = edge.getPoints();

				// Checks if we're dealing with a routing algorithm
				// and if we are, replaces only the source and target
				// in the control point list.
				if (controlPoints != currentPoints) {
					controlPoints.set(0, edge.getPoint(0));
					controlPoints.set(controlPoints.size() - 1, edge
							.getPoint(edge.getPointCount() - 1));
				}

				if (clone) {
					Map cellMap = graph.cloneCells(graph
							.getDescendants(new Object[] { edge.getCell() }));
					processNestedMap(nested, true);
					nested = GraphConstants.replaceKeys(cellMap, nested);
					cs = cs.clone(cellMap);
					Object[] cells = cellMap.values().toArray();
					graph.getGraphLayoutCache().insert(cells, nested, cs, null,
							null);
				} else {
					processNestedMap(nested, false);
					graph.getGraphLayoutCache().edit(nested, cs, null, null);
				}
			} else {
				if (graph.isXorEnabled()) {
					overlay(graph.getGraphics());
				} else {
					Rectangle2D dirty = edge.getBounds();
					graph.repaint((int) dirty.getX(), (int) dirty.getY(),
							(int) dirty.getWidth(), (int) dirty.getHeight());
				}
				edge.refresh(graph.getGraphLayoutCache(), graph.getGraphLayoutCache(),
						false);
			}
			initialLabelLocation = null;
			currentPoint = null;
			this.edgeModified = false;
			this.label = false;
			this.source = false;
			this.target = false;
			currentLabel = -1;
			currentIndex = -1;
			firstOverlayCall = true;
			e.consume();
		}

		protected void processNestedMap(Map nested, boolean clone) {
			// subclassers can override this to modify the attributes
		}

		protected ConnectionSet createConnectionSet(EdgeView view,
				boolean verbose) {
			Object edge = view.getCell();
			GraphModel model = graph.getModel();
			ConnectionSet cs = new ConnectionSet();
			Object sourcePort = null, targetPort = null;
			if (view.getSource() != null)
				sourcePort = view.getSource().getCell();
			else if (view.getSourceParentView() != null)
				sourcePort = model.getSource(edge);
			if (view.getTarget() != null)
				targetPort = view.getTarget().getCell();
			else if (view.getTargetParentView() != null)
				targetPort = model.getTarget(edge);
			if (view.getTarget() != null)
				targetPort = view.getTarget().getCell();
			if (verbose || (sourcePort != model.getSource(edge) && source))
				cs.connect(edge, sourcePort, true);
			if (verbose || (targetPort != model.getTarget(edge) && target))
				cs.connect(edge, targetPort, false);
			return cs;
		}

		// Update control points
		protected void invalidate() {
			EdgeView e = relevantEdge;
			int handlesize = graph.getHandleSize();
			EdgeRenderer er = (EdgeRenderer) edge.getRenderer();
			Point2D labelPosition = er.getLabelPosition(e);
			Point2D p = null;
			if (labelPosition != null) {
				p = (Point2D)labelPosition.clone();
				graph.toScreen(p);
			}
			Dimension d = er.getLabelSize(e, graph.convertValueToString(e));
			if (p != null && d != null) {
				Point2D s = graph.toScreen(new Point2D.Double(d.width,
						d.height));
				loc.setFrame(p.getX() - s.getX() / 2, p.getY() - s.getY()
						/ 2, s.getX(), s.getY());
			}
			for (int i = 0; i < r.length; i++) {
				p = e.getPoint(i);
				p = graph.toScreen(new Point2D.Double(p.getX(), p.getY()));
				r[i].setFrame(p.getX() - handlesize, p.getY() - handlesize,
						2 * handlesize, 2 * handlesize);

			}
			if (extraLabelLocations != null) {
				for (int i = 0; i < extraLabelLocations.length; i++) {
					p = er.getExtraLabelPosition(e, i);
					if (p != null) {
						p = graph.toScreen((Point2D) p.clone());
						d = er.getExtraLabelSize(graph, e, i);
						if (d != null) {
							Point2D s = graph.toScreen(new Point2D.Double(
									d.width, d.height));
							extraLabelLocations[i].setFrame(p.getX() - s.getX()
									/ 2, p.getY() - s.getY() / 2, s.getX(), s
									.getY());
						}
					}
				}
			}
		}

	}

	public Point2D getPerimeterPoint(EdgeView edge, Point2D source, Point2D p) {
		if (getPointCount() > 2)
			return getPoint(getPointCount() / 2);
		Point2D p0 = getPoint(0);
		Point2D pe = getPoint(getPointCount() - 1);
		return new Point2D.Double((pe.getX() + p0.getX()) / 2, (pe.getY() + p0
				.getY()) / 2);
	}
}