| /******************************************************************************* |
| * 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(); |
| } |
| } |
