/*******************************************************************************
* 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.ArrayList;
import java.util.List;
import org.eclipse.core.runtime.Assert;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.gef.EditPart;
import org.eclipse.gef.GraphicalEditPart;
import org.eclipse.jst.pagedesigner.IHTMLConstants;
import org.eclipse.jst.pagedesigner.css2.layout.CSSFigure;
import org.eclipse.jst.pagedesigner.css2.layout.CSSTextFigure;
import org.eclipse.jst.pagedesigner.css2.layout.FlowBox;
import org.eclipse.jst.pagedesigner.css2.layout.FlowUtilities;
import org.eclipse.jst.pagedesigner.css2.layout.TextFragmentBox;
import org.eclipse.jst.pagedesigner.css2.layout.TextLayoutSupport;
import org.eclipse.jst.pagedesigner.dom.DOMRefPosition;
import org.eclipse.jst.pagedesigner.dom.EditModelQuery;
import org.eclipse.jst.pagedesigner.parts.SubNodeEditPart;
import org.eclipse.jst.pagedesigner.parts.TextEditPart;
import org.eclipse.jst.pagedesigner.validation.caret.IPositionMediator;
import org.eclipse.jst.pagedesigner.validation.caret.Target;
import org.w3c.dom.Node;
/**
* @author mengbo
*/
public final class LayoutPart {
private final static int MAX_OFFSET_TO_EDGE = 10;
private EditPart _part;
private FlowBox _box;
private final Point EMPTY_POINT = new Point(0, 0);
private Point _point = EMPTY_POINT;
/**
* If caller didn't resolve FlowBox, call this.
*
* @param part
* @param point
*/
public LayoutPart(EditPart part, Point point) {
Assert.isTrue(part != null);
_part = part;
_point = point;
}
/**
* @return Returns the _box, when it is null, generate box with part and
* point.
*/
public FlowBox getBox() {
if (_box == null) {
_box = getClosestBox();
}
return _box;
}
/**
* @return Returns the _part.
*/
public EditPart getPart() {
return _part;
}
/**
* Get closest box's bounds.
*
* @param point
* @return
*/
private Rectangle getClosestBoxAbsoluteBounds() {
Rectangle rect = null;
if (getBox() != null) {
rect = getAbsoluteBounds(getBox());
}
return rect;
}
/**
* Try to get the closest flowbox absolute bounds.
*
* @return the bounding rectangle
*/
public Rectangle getAbsoluteBounds() {
Rectangle bounds = null;
if ((bounds = getClosestBoxAbsoluteBounds()) == null) {
// This should never happens.
bounds = EditPartPositionHelper.getAbsoluteBounds(_part);
}
return bounds;
}
/**
* Get box's absolute bounds.
*
* @param box
* @return the box's bounding rectangle
*/
public Rectangle getAbsoluteBounds(FlowBox box) {
if (box != null) {
IFigure figure = ((GraphicalEditPart) _part).getFigure();
Rectangle rect = new Rectangle(box.getX(), box.getY(), box.getWidth(), box
.getHeight());
figure.translateToAbsolute(rect);
return rect;
}
return null;
}
/**
* Closest box is the part's FlowBox which y coordinate is closest to point,
* and then its x coordinate is more close to point than other boxs of the
* same line.
*
* @param part
* @param point
* @return
*/
private FlowBox getClosestBox() {
FlowBox closestBox = null;
List fragments = getLines(_part);
// if there is one which are at the same line with relative,
// calculate that line first;
for (int i = 0; i < fragments.size(); i++) {
FlowBox box = (FlowBox) fragments.get(i);
Rectangle boxRect = getAbsoluteBounds(box);
if (boxRect.contains(_point.x, _point.y)) {
closestBox = box;
break;
}
if (closestBox == null) {
closestBox = box;
} else {
// compare y.
int offset1 = Math.abs(CaretPositionResolver.getYDistance(
boxRect, _point));
Rectangle closestRect = getAbsoluteBounds(closestBox);
int offset2 = Math.abs(CaretPositionResolver.getYDistance(
closestRect, _point));
if (offset1 < offset2) {
closestBox = box;
}
}
// at the same line
if (closestBox != box && boxRect.contains(boxRect.x, _point.y)) {
// compare x.
int offset1 = Math.abs(CaretPositionResolver.getXDistance(
boxRect, _point));
Rectangle closestRect = getAbsoluteBounds(closestBox);
int offset2 = Math.abs(CaretPositionResolver.getXDistance(
closestRect, _point));
if (offset1 < offset2) {
closestBox = box;
}
}
}
return closestBox;
}
/**
* The point is whitin the bounds of the figure.
*
* @param point
* @return true if point is the absolute bounds of this
*/
public boolean contains(Point point) {
return getAbsoluteBounds().contains(point);
}
/**
* @return the design position
*/
public DesignPosition resolveTextPosition() {
DesignPosition result = null;
if (_part instanceof TextEditPart
&& !EditModelQuery.isTransparentText(Target.resolveNode(_part))) {
FlowBox flowBox = getBox();
if (flowBox instanceof TextFragmentBox) {
TextFragmentBox box = (TextFragmentBox) flowBox;
if (((TextEditPart) _part).getFigure() instanceof CSSTextFigure) {
CSSTextFigure figure = (CSSTextFigure) ((TextEditPart) _part)
.getFigure();
Rectangle boxRect = getAbsoluteBounds(box);
int index = FlowUtilities.getTextInWidth(box.getTextData(),
figure.getCSSStyle().getCSSFont().getSwtFont(),
_point.x - boxRect.x, TextLayoutSupport
.getAverageCharWidth(box));
result = new DesignPosition(_part, box._offset + index);
}
}
}
return result;
}
/**
* @param validator
* @return resolve the design position using validator
*/
public DesignPosition resolvePosition(IPositionMediator validator) {
DesignPosition result;
if ((result = resolveTextPosition()) == null) {
boolean atPointLeft = isBeforePoint(_point);
// boolean atPointRight = isAfterPoint(_point);
// if (atPointLeft == atPointRight) {
// // TODO: and...?
// }
Target target = new Target(getPart());
if (validator.isValidPosition(new DOMRefPosition(target.getNode(),
atPointLeft))) {
result = new DesignRefPosition(_part, atPointLeft);
} else if (validator.isValidPosition(new DOMRefPosition(target
.getNode(), !atPointLeft))) {
result = new DesignRefPosition(_part, !atPointLeft);
} else if (validator.isEditable(target)) {
if (atPointLeft) {
result = new DesignPosition(_part, 0);
} else {
result = new DesignPosition(_part, _part.getChildren()
.size());
}
}
}
return result;
}
// TODO: dead?
// private IFigure getFigure() {
// return ((GraphicalEditPart) _part).getFigure();
// }
private boolean isAfterPoint(Point point) {
boolean result = false;
FlowBox flowBox = getLine(0);
if (IHTMLConstants.TAG_BR.equalsIgnoreCase(Target.resolveNode(_part)
.getNodeName())) {
if (flowBox != null) {
Rectangle boxRect = getAbsoluteBounds(flowBox);
result = CaretPositionResolver.getYDistance(boxRect, point) == 0;
}
} else {
if (flowBox != null) {
Rectangle boxRect = getAbsoluteBounds(flowBox);
if (CaretPositionResolver.getXDistance(boxRect, point) != 0) {
result = CaretPositionResolver.getXDistance(boxRect, point) < 0
&& //
CaretPositionResolver.getYDistance(boxRect, point) == 0;
}
}
}
result |= isUnderCaret();
// if (isWidget() && flowBox != null)
// {
// result |= contains(point) &&
// CaretPositionResolver.toXMiddle(getAbsoluteBounds(flowBox), point) <
// 0;
// }
return result;
}
/*package*/ boolean isBeforePoint(Point point) {
boolean result = false;
FlowBox flowBox = getLastLine();
if (flowBox != null) {
Rectangle boxRect = getAbsoluteBounds(flowBox);
if (IHTMLConstants.TAG_BR.equalsIgnoreCase(Target
.resolveNode(_part).getNodeName())) {
return CaretPositionResolver.getYDistance(boxRect, point) == 0;
} else if (CaretPositionResolver.getXDistance(boxRect, point) != 0) {
result = CaretPositionResolver.getXDistance(boxRect, point) > 0
&& //
CaretPositionResolver.getYDistance(boxRect, point) == 0;
}
}
result |= isAboveCaret();
// if (isWidget() && flowBox != null)
// {
// result |= contains(point) &&
// CaretPositionResolver.toXMiddle(getAbsoluteBounds(flowBox), point) >
// 0;
// }
return result;
// return !isAfterPoint(point);
}
/*package*/ boolean isBeforePoint() {
return isBeforePoint(_point);
}
/*package*/ boolean atLeftPart(Point point) {
FlowBox flowBox = getBox();
if (flowBox != null) {
Rectangle boxRect = getAbsoluteBounds(flowBox);
return CaretPositionResolver.toXMiddle(boxRect, point) < 0;
}
return true;
}
/*package*/ boolean isAfterPoint() {
return isAfterPoint(_point);
}
// TODO: dead but possibly useful?
// private boolean atSameLine(Point point) {
// Rectangle bounds = getAbsoluteBounds();
// return bounds.contains(bounds.getTop().x, point.y);
// }
/*package*/ boolean atSameRow(Point point) {
Rectangle bounds = getAbsoluteBounds();
return bounds.contains(point.x, bounds.getRight().y);
}
/*package*/ static Rectangle getBounds(FlowBox box) {
return new Rectangle(box.getX(), box.getY(), box.getWidth(), box.getHeight());
}
/**
* @return Returns the _point.
*/
public Point getPoint() {
return _point;
}
FlowBox getLine(int index) {
FlowBox result = null;
List lines = getLines(_part);
if (lines.size() > 0 && index >= 0 && index <= lines.size() - 1) {
result = (FlowBox) lines.get(index);
}
return result;
}
FlowBox getLastLine() {
FlowBox result = null;
List lines = getLines(_part);
if (lines.size() > 0) {
result = (FlowBox) lines.get(lines.size() - 1);
}
return result;
}
/**
* @param part
* @return
*/
List getLines(EditPart part) {
List fragments = new ArrayList();
if (part instanceof SubNodeEditPart) {
IFigure figure = ((GraphicalEditPart) part).getFigure();
if (figure instanceof CSSTextFigure) {
fragments = ((CSSTextFigure) figure).getFragments();
((CSSTextFigure) figure).getCSSStyle();
} else if (figure instanceof CSSFigure) {
fragments = ((CSSFigure) figure).getFragmentsForRead();
((CSSFigure) figure).getCSSStyle();
}
}
return fragments;
}
/**
* To search for none empty string, this is not final.
* @param part
* @return the edit part
*
*/
/*package*/ static EditPart getConcretePart(EditPart part) {
if (part != null) {
Node node = Target.resolveNode(part);
Node child = node.getFirstChild();
EditPart result;
while (child != null) {
if (!EditModelQuery.isTransparentText(child)
&& (result = Target.resolvePart(child)) != null) {
return result;
}
child = child.getNextSibling();
}
}
return null;
}
/**
* To search for none empty string, this is not final.
* Equivalent to getConcretePart(getPart())
*
* @return the edit part
*
*/
public EditPart getConcretePart() {
return getConcretePart(_part);
}
/**
* @param node
* @return the node
*/
public static Node getConcreteNode(Node node) {
if (node != null) {
Node child = node.getFirstChild();
while (child != null) {
if (!EditModelQuery.isTransparentText(child)) {
return node;
}
child = child.getNextSibling();
}
}
return null;
}
/**
* @return true if is close to edge
*/
public boolean isCloseToEdgeFromOutSide() {
boolean result = false;
if (EditModelQuery.isBlockNode(Target.resolveNode(_part))) {
result = Math.abs(getAbsoluteBounds().getLeft().x - _point.x) <= MAX_OFFSET_TO_EDGE;
if (!result) {
result = Math.abs(getAbsoluteBounds().getRight().x - _point.x) <= MAX_OFFSET_TO_EDGE;
}
}
return result;
}
private boolean isAboveCaret() {
return getAbsoluteBounds().getBottom().y <= _point.y;
}
private boolean isUnderCaret() {
return getAbsoluteBounds().getTop().y >= _point.y;
}
/**
* @return tru if getPart() is considered inline
*/
/*package*/ boolean isInline() {
return EditModelQuery.isInline(Target.resolveNode(_part));
}
// TODO: dead?
// private boolean isWidget() {
// return EditModelQuery.isWidget(_part);
// }
/*
* (non-Javadoc)
*
* @see java.lang.Object#toString()
*/
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append("editPart:" + _part + ", --- box: " + getBox()); //$NON-NLS-1$ //$NON-NLS-2$
return sb.toString();
}
}