jsf/plugins/org.eclipse.jst.pagedesigner/src/org/eclipse/jst/pagedesigner/viewer/CaretPositionResolver.java

/*******************************************************************************
 * Copyright (c) 2006 Sybase, Inc. 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:
 *     Sybase, Inc. - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.pagedesigner.viewer;

import java.util.List;

import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.EditPart;
import org.eclipse.jst.pagedesigner.IHTMLConstants;
import org.eclipse.jst.pagedesigner.dom.EditModelQuery;
import org.eclipse.jst.pagedesigner.validation.caret.IMovementMediator;
import org.eclipse.jst.pagedesigner.validation.caret.IPositionMediator;
import org.eclipse.jst.pagedesigner.validation.caret.Target;
import org.w3c.dom.Node;

/**
 * @author mengbo
 * @version 1.5
 */
public class CaretPositionResolver {
	private IPositionMediator _validator;

	private Point _point;

	private static CaretPositionResolver _instance;

	/**
	 * @param validator
	 * @param point
	 * @return the singleton instance
	 */
	public static CaretPositionResolver getInstance(
			IPositionMediator validator, Point point) {
		if (_instance == null) {
			_instance = new CaretPositionResolver();
		}
		_instance.setPoint(point);
		_instance.setValidator(validator);
		return _instance;
	}

	/**
	 * @param _point
	 *            The _point to set.
	 */
	private void setPoint(Point _point) {
		this._point = _point;
	}

	/**
	 * @param _validator
	 *            The _validator to set.
	 */
	private void setValidator(IPositionMediator _validator) {
		this._validator = _validator;
	}

	/**
	 * Calculate the two part's distance to point, the shorter one will be
	 * return. Distance is calculated based on: if there is one box contains
	 * point.y, then calculate that box, or if there is no any such one box,
	 * then calculate the y distance.
	 * 
	 * @param part1
	 * @param part2
	 * @param point
	 * @return
	 */
	static LayoutPart getCloserPart(LayoutPart part1, LayoutPart part2,
			Point _point) {
		if (part1 == null
				|| EditModelQuery.isTransparentText(Target.resolveNode(part1
						.getPart()))) {
			return part2;
		} else if (part2 == null
				|| EditModelQuery.isTransparentText(Target.resolveNode(part2
						.getPart()))) {
			return part1;
		}
		Rectangle rect1 = part1.getAbsoluteBounds();
		Rectangle rect2 = part2.getAbsoluteBounds();
		Node n1 = Target.resolveNode(part1.getPart());
		Node n2 = Target.resolveNode(part2.getPart());
		// Within same.
		if (EditModelQuery.isChild(n1, n2)
				&& (CaretPositionResolver.getXDistance(rect2, _point) == 0)
				&& !part1.isCloseToEdgeFromOutSide()) {
			return part2;
		} else if (EditModelQuery.isChild(n2, n1)
				&& (CaretPositionResolver.getXDistance(rect1, _point) == 0 && !part2
						.isCloseToEdgeFromOutSide())
				&& !part2.isCloseToEdgeFromOutSide()) {
			return part1;
		}
		if (rect1.intersect(new Rectangle(rect1.x, rect2.y, rect1.width,
				rect2.height)).height == 0) {
			return heightFirst(part1, part2, _point);
		}
        return widthFirst(part1, part2, _point);
	}

	private static LayoutPart heightFirst(LayoutPart part1, LayoutPart part2,
			Point _point) {
		Rectangle rect1 = part1.getAbsoluteBounds();
		Rectangle rect2 = part2.getAbsoluteBounds();
		int offset1 = Math.abs(CaretPositionResolver
				.getYDistance(rect1, _point));
		int offset2 = Math.abs(CaretPositionResolver
				.getYDistance(rect2, _point));
		if (offset1 > offset2) {
			return part2;
		} else if (offset1 < offset2) {
			return part1;
		} else {
			offset1 = Math.abs(CaretPositionResolver
					.getXDistance(rect1, _point));
			offset2 = Math.abs(CaretPositionResolver
					.getXDistance(rect2, _point));
			if (offset1 >= offset2) {
				return part2;
			}
            return part1;
		}
	}

	private static LayoutPart widthFirst(LayoutPart part1, LayoutPart part2,
			Point _point) {
		Rectangle rect1 = part1.getAbsoluteBounds();
		Rectangle rect2 = part2.getAbsoluteBounds();
		int offset1 = Math.abs(CaretPositionResolver
				.getXDistance(rect1, _point));
		int offset2 = Math.abs(CaretPositionResolver
				.getXDistance(rect2, _point));
		if (offset1 > offset2) {
			return part2;
		} else if (offset1 < offset2) {
			return part1;
		} else {
			offset1 = Math.abs(CaretPositionResolver
					.getYDistance(rect1, _point));
			offset2 = Math.abs(CaretPositionResolver
					.getYDistance(rect2, _point));
			if (offset1 >= offset2) {
				return part2;
			}
            return part1;
		}
	}

	/**
	 * Return a descendent part under parent that is one of the closest part to
	 * point.
	 * 
	 * @param parent
	 * @return
	 */
	private LayoutPart getClosestChildPart(LayoutPart parent) {
		LayoutPart result = null;
		if (parent != null) {
			List children = null;
			if ((children = parent.getPart().getChildren()).size() > 0) // &&
			// _validator.hasEditableArea(new
			// Target(parent.getPart())))
			{
				// iterate its children, we know the part doesn't contain p. so
				// we only see if its children can be
				// referenced.
				for (int i = 0, n = children.size(); i < n; i++) {
					LayoutPart nextPart = new LayoutPart((EditPart) children
							.get(i), _point);
					Target target = new Target(nextPart.getPart());
					if (_validator.isValidPosition(new DesignRefPosition(target
							.getPart(), false))) {
						result = getCloserPart(result, nextPart, _point);
					} else if (_validator.hasEditableArea(target)) {
						LayoutPart temp = getClosestChildPart(nextPart);
						if (temp == null) {
							temp = nextPart;
						}
						result = getCloserPart(result, temp, _point);
					}
				}
			}
		}
		return result;
	}

	/**
	 * Use by vertical movement, we need to see whther the par
	 * 
	 * @param closestPart
	 * @param target
	 * @return
	 */
	LayoutPart resolveClosestPartFrom(LayoutPart closestPart) {
		Target target = new Target(closestPart.getPart());
		LayoutPart finalPart = null;
		if (EditModelQuery.isInline(Target.resolveNode(closestPart.getPart()))) {

			if (closestPart.isAfterPoint() || closestPart.isBeforePoint()) {
				finalPart = closestPart;
			} else {
				if (_validator.hasEditableArea(target)
						&& (_validator instanceof IMovementMediator
								&& ((IMovementMediator) _validator)
										.allowsMoveIn(target) || !(_validator instanceof IMovementMediator))) {
					finalPart = getClosestChildPartOrPart(closestPart);
				}
			}
		}
		// block
		else {
			if (closestPart.contains(_point)) {
				if (_validator.hasEditableArea(target) && //
						(_validator instanceof IMovementMediator
								&& ((IMovementMediator) _validator)
										.allowsMoveIn(target) || !(_validator instanceof IMovementMediator))) {
					finalPart = getClosestChildPartOrPart(closestPart);
				}
			}
			// outside of bounds
			else {
				if (_validator.hasEditableArea(target)
						&& !IHTMLConstants.TAG_TABLE.equalsIgnoreCase(target
								.getNode().getNodeName())
						&& (_validator instanceof IMovementMediator
								&& ((IMovementMediator) _validator)
										.allowsMoveIn(target) || !(_validator instanceof IMovementMediator))) {
					if (closestPart.atSameRow(_point)) {
						finalPart = getClosestChildPartOrPart(closestPart);
					} else if (!_validator
							.isValidPosition(new DesignRefPosition(target
									.getPart(), true))) {
						finalPart = getClosestChildPartOrPart(closestPart);
					}
				}
			}
		}
		if (finalPart == null && //
				(_validator.isValidPosition(new DesignRefPosition(target
						.getPart(), true)) || // 
				_validator.isValidPosition(new DesignRefPosition(target
						.getPart(), false)))) {
			finalPart = closestPart;
		}
		return finalPart;
	}

	private LayoutPart getClosestChildPartOrPart(LayoutPart closestPart) {
		LayoutPart result = getClosestChildPart(closestPart);
		if (result != null) {
			result = resolveClosestPartFrom(result);
		} else {
			if (closestPart.getConcretePart() == null) {
				result = closestPart;
			}
		}
		return result;
	}

	/**
	 * Get the distance from rect's edge to point.x.
	 * 
	 * @param rect
	 * @param point
	 * @return the X distance
	 */
	public static int getXDistance(Rectangle rect, Point point) {
		if (rect.getRight().x <= point.x) {
			return point.x - (rect.getRight().x);
		} else if (rect.x >= point.x) {
			return point.x - rect.x;
		} else if (rect.x <= point.x && point.x <= rect.getRight().x) {
			return 0;
		}
		return -1;
	}

	/**
	 * from point to middle's distance. If the result is nagative, point is at
	 * left part of rect, if it is positive, the point is at the right part.
	 * 
	 * @param rect
	 * @param point
	 * @return the X distance
	 */
	public static int toXMiddle(Rectangle rect, Point point) {
		return (point.x - (rect.x + rect.getRight().x) / 2);
	}

	/**
	 * from point to middle's distance If the result is nagative, point is at
	 * upper part of rect, if it is positive, the point is at the lower part.
	 * 
	 * @param rect
	 * @param point
	 * @return the Y distance
	 */
	public static int toYMiddle(Rectangle rect, Point point) {
		return (point.y - (rect.y + rect.getBottom().y) / 2);
	}

	/**
	 * @param rect
	 * @param point
	 * @return the Y distance
	 */
	public static int getYDistance(Rectangle rect, Point point) {
		if (rect.y + rect.height <= point.y) {
			return point.y - (rect.y + rect.height);
		} else if (rect.y >= point.y) {
			return point.y - rect.y;
		} else if (rect.y <= point.y && point.y <= rect.y + rect.height) {
			return 0;
		}
		return -1;
	}
}