/**
* straightenPoints This is a simpler version of the.
*
* @see updateIfNotRectilinear that simply ensures that the lines are horizontal or vertical
* without any intelligence in terms of shortest distance around a rectangle.
* @param newLine PointList to check for rectilinear qualities and change if necessary.
* @param tolerance int tolerance value by which points will be straightened in HiMetrics
*/
protected static void straightenPoints(final PointList newLine, final int tolerance) {
for (int i = 0; i < newLine.size() - 1; i++) {
final Point ptCurrent = newLine.getPoint(i);
final Point ptNext = newLine.getPoint(i + 1);
final int xDelta = Math.abs(ptNext.x - ptCurrent.x);
final int yDelta = Math.abs(ptNext.y - ptCurrent.y);
if (xDelta < yDelta) {
if (xDelta > tolerance) {
return;
}
if (i == newLine.size() - 2) {
// The last point is more important than the other (not
// change the end of the line)
ptCurrent.x = ptNext.x;
} else {
ptNext.x = ptCurrent.x;
}
} else {
if (yDelta > tolerance) {
return;
}
if (i == newLine.size() - 2) {
// The last point is more important than the other (not
// change the end of the line)
ptCurrent.y = ptNext.y;
} else {
ptNext.y = ptCurrent.y;
}
}
newLine.setPoint(ptNext, i + 1);
}
}
private boolean trunkVertexEqual(final Connection connMaster, final Connection connSlave) {
final PointList cmPts = connMaster.getPoints();
final PointList csPts = connSlave.getPoints();
if (cmPts.size() > 2 && csPts.size() > 2) {
return cmPts.getPoint(2).equals(csPts.getPoint(2));
}
return false;
}
@Override
protected List<?> createSelectionHandles() {
List<BendpointHandle> list = new ArrayList<BendpointHandle>();
ConnectionEditPart connEP = (ConnectionEditPart) getHost();
PointList points = getConnection().getPoints();
List<?> bendPoints = (List<?>) getConnection().getRoutingConstraint();
int bendPointIndex = 0;
Point currBendPoint = null;
if (bendPoints == null) bendPoints = NULL_CONSTRAINT;
else if (!bendPoints.isEmpty()) currBendPoint = ((Bendpoint) bendPoints.get(0)).getLocation();
for (int i = 0; i < points.size() - 1; i++) {
// Put a create handle on the middle of every segment
list.add(new SnappingBendpointCreationHandle(connEP, bendPointIndex, i));
// If the current user bendpoint matches a bend location, show a
// move handle
if (i < points.size() - 1
&& bendPointIndex < bendPoints.size()
&& currentBendPointMatches(currBendPoint, points.getPoint(i + 1))) {
list.add(new SnappingBendpointMoveHandle(connEP, bendPointIndex, i + 1));
// Go to the next user bendpoint
bendPointIndex++;
if (bendPointIndex < bendPoints.size())
currBendPoint = ((Bendpoint) bendPoints.get(bendPointIndex)).getLocation();
}
}
return list;
}
protected List<BezierPoint> getBezierPoints(PointList points, double zoom) {
List<BezierPoint> ret = new ArrayList<BezierPoint>(points.size());
for (int i = 0; i < points.size(); i++) {
int bezierDistance = (int) (getGeneralBezierDistance() * zoom);
Point point = points.getPoint(i);
ret.add(new BezierPoint(point.x, point.y, bezierDistance, bezierDistance));
}
return ret;
}
/** @param newConstraint */
private void validateConstraint(List newConstraint) {
getTreeRouter().setConstraint(getConnection1(), newConstraint);
PointList ptl1 = getTreeRouter().getPointsFromConstraint(getConnection1());
getTreeRouter().route(getConnection2());
getTreeRouter().route(getConnection1());
assertTrue(
"Connection1 points aren't orthogonal", //$NON-NLS-1$
getTreeRouter().isOrthogonalTreeBranch(getConnection1(), ptl1));
PointList c1Pts = getConnection1().getPoints();
PointList c2Pts = getConnection2().getPoints();
assertTrue(
"Connection2 points aren't orthogonal", //$NON-NLS-1$
getTreeRouter().isOrthogonalTreeBranch(getConnection2(), c2Pts));
assertTrue(
"Trunk values don't match after tree routing", //$NON-NLS-1$
c1Pts.getPoint(2).equals(c2Pts.getPoint(2)));
}
public void testMoveShape() {
List newConstraint = initializeConstraint(test1, test1Start, test1End, test1Other);
getTreeRouter().setConstraint(getConnection1(), newConstraint);
getTreeRouter().route(getConnection2());
getTreeRouter().route(getConnection1());
Rectangle newBounds = new Rectangle(test1Start);
newBounds.translate(4000, 4000);
getConnection1().getSourceAnchor().getOwner().setBounds(newBounds);
getTreeRouter().route(getConnection1());
getConnection2().validate();
PointList c1Pts = getConnection1().getPoints();
PointList c2Pts = getConnection2().getPoints();
assertTrue(
"Trunk values don't match after tree routing", //$NON-NLS-1$
c1Pts.getPoint(2).equals(c2Pts.getPoint(2)));
}
@Override
public boolean test() throws Exception {
boolean location = false;
PointList points = ((PolylineConnectionEx) connectionEditPart.getFigure()).getPoints();
if (checkFirstBendpoint) {
location = !initialLocation.equals(points.getFirstPoint());
} else if (checkLastBendpoint) {
location = !initialLocation.equals(points.getLastPoint());
} else if (bendpointPosition >= 0 || bendpointPosition < points.size()) {
location = !initialLocation.equals(points.getPoint(bendpointPosition));
}
return location;
}
@Override
public void route(Connection conn) {
if (isDirty) {
ignoreInvalidate = true;
processStaleConnections();
isDirty = false;
List<?> updated = algorithm.solve();
Connection current;
for (int i = 0; i < updated.size(); i++) {
Path path = (Path) updated.get(i);
current = (Connection) path.data;
current.revalidate();
PointList points = path.getPoints().getCopy();
Point ref1;
Point ref2;
Point start;
Point end;
ref1 = new PrecisionPoint(points.getPoint(1));
ref2 = new PrecisionPoint(points.getPoint(points.size() - 2));
current.translateToAbsolute(ref1);
current.translateToAbsolute(ref2);
start = current.getSourceAnchor().getLocation(ref1).getCopy();
end = current.getTargetAnchor().getLocation(ref2).getCopy();
current.translateToRelative(start);
current.translateToRelative(end);
points.setPoint(start, 0);
points.setPoint(end, points.size() - 1);
current.setPoints(points);
}
ignoreInvalidate = false;
}
}
/**
* UpdateConstraint Updates the constraint value for the connection based on the tree vertex.
*
* @param conn Connection whose constraint is to be updated.
*/
protected void updateConstraint(final Connection conn) {
boolean update =
conn != null && conn.getSourceAnchor() != null && conn.getTargetAnchor() != null;
update =
update
&& conn.getSourceAnchor().getOwner() != null
&& conn.getTargetAnchor().getOwner() != null;
if (update) {
if (isUpdatingPeers()) {
return;
}
List bendpoints = (List) conn.getRoutingConstraint();
if (bendpoints == null) {
bendpoints = new ArrayList(conn.getPoints().size());
}
final Point sourceRefPoint = conn.getSourceAnchor().getReferencePoint();
conn.translateToRelative(sourceRefPoint);
final Point targetRefPoint = conn.getTargetAnchor().getReferencePoint();
conn.translateToRelative(targetRefPoint);
final Point ptTrunk = getTrunkLocation(conn);
final Point ptSource = getBranchRouter().getSourceLocation(conn, ptTrunk);
bendpoints.clear();
final PointList pts = getBranchRouter().recreateBranch(conn, ptSource, ptTrunk);
for (int i = 0; i < pts.size(); i++) {
final Bendpoint bp = new AbsoluteBendpoint(pts.getPoint(i));
bendpoints.add(bp);
}
setUpdatingPeers(true);
try {
setConstraint(conn, bendpoints);
conn.invalidate();
conn.validate();
} finally {
setUpdatingPeers(false);
}
}
}
/**
* Utility method to determine if the given set of points conforms to the constraints of being an
* orthogonal connection tree-branch. 1. Points size must be 4. 2. Source point resides with-in
* boundary of source shape based on orientation 3. Target point resides with-in boundary of
* target shape based on orientation 4. Middle line is perpendicular to the 2 end lines.
*
* @param conn the <code>Connection</code> to test
* @param points <code>PointList</code> to test constraints against
* @return <code>boolean</code> <code>true</code> if points represent valid orthogaonl tree
* branch, <code>false</code> otherwise.
*/
public boolean isOrthogonalTreeBranch(final Connection conn, final PointList points) {
boolean result = false;
if (isTreeBranch(conn, points)) {
final LineSeg branch = new LineSeg(points.getPoint(0), points.getPoint(1));
final LineSeg trunkShoulder = new LineSeg(points.getPoint(1), points.getPoint(2));
final LineSeg trunk = new LineSeg(points.getPoint(2), points.getPoint(3));
if (isTopDown(conn)) {
result = branch.isVertical() && trunkShoulder.isHorizontal() && trunk.isVertical();
} else {
result = branch.isHorizontal() && trunkShoulder.isVertical() && trunk.isHorizontal();
}
}
return result;
}
/**
* Utility method to determine if the given set of points conforms to the constraints of being a
* connection tree-branch. 1. Points size must be 4. 2. Source point resides with-in boundary of
* source shape based on orientation 3. Target point resides with-in boundary of target shape
* based on orientation
*
* @param conn the <code>Connection</code> to test
* @param points the <code>PointList</code> to test constraints against
* @return <code>boolean</code> <code>true</code> if points represent valid tree branch, <code>
* false</code> otherwise.
*/
public boolean isTreeBranch(final Connection conn, final PointList points) {
boolean result = false;
if (points.size() == 4) {
// just check if ends are with-in the owner bounding box
final Rectangle targetBounds = getTargetAnchorRelativeBounds(conn);
final Rectangle sourceBounds = getSourceAnchorRelativeBounds(conn);
if (isTopDown(conn)) {
result =
(points.getPoint(0).x > sourceBounds.x
&& points.getPoint(0).x < sourceBounds.x + sourceBounds.width)
&& (points.getPoint(3).x > targetBounds.x
&& points.getPoint(3).x < targetBounds.x + targetBounds.width);
} else {
result =
(points.getPoint(0).y > sourceBounds.y
&& points.getPoint(0).y < sourceBounds.y + sourceBounds.height)
&& (points.getPoint(3).y > targetBounds.y
&& points.getPoint(3).y < targetBounds.y + targetBounds.height);
}
}
return result;
}
public void layout(IFigure container) {
Rectangle area = container.getClientArea();
// calculate a virtual area
if (scale != null && scale.isDirty())
M =
Math.max(
FigureUtilities.getTextWidth(
scale.format(scale.getRange().getLower()), scale.getFont()),
FigureUtilities.getTextWidth(
scale.format(scale.getRange().getUpper()), scale.getFont()))
/ 2;
int h = area.height;
int w = area.width;
if (h > HW_RATIO * (w - 2 * M)) h = (int) (HW_RATIO * (w - 2 * M));
// else if (w > h/HW_RATIO + 2*M)
// w = (int) (h/HW_RATIO + 2*M);
double r = h / (1 - Math.sin(ALPHA) / 2);
int x = (int) (area.x - r * (1.0 - Math.cos(ALPHA)) + M);
int y = area.y;
area = new Rectangle(x, y, (int) (2 * r), (int) (2 * r));
Point center = area.getCenter();
if (scale != null) {
scale.setBounds(area);
}
if (ramp != null && ramp.isVisible()) {
Rectangle rampBounds = area.getCopy();
ramp.setBounds(
rampBounds.shrink(
area.width / 4 - ramp.getRampWidth(), area.height / 4 - ramp.getRampWidth()));
}
if (valueLabel != null) {
Dimension labelSize = valueLabel.getPreferredSize();
valueLabel.setBounds(
new Rectangle(
area.x + area.width / 2 - labelSize.width / 2,
area.y
+ area.height / 2
- area.height / 4
- (scale.getInnerRadius() - area.height / 4) / 2
- labelSize.height / 2,
labelSize.width,
labelSize.height));
}
if (needle != null && scale != null) {
needlePoints.setPoint(
new Point(center.x + area.width / 4, center.y - NEEDLE_WIDTH / 2 + 3), 0);
scale.getScaleTickMarks();
needlePoints.setPoint(
new Point(center.x + scale.getInnerRadius() - GAP_BTW_NEEDLE_SCALE, center.y), 1);
needlePoints.setPoint(
new Point(center.x + area.width / 4, center.y + NEEDLE_WIDTH / 2 - 3), 2);
double valuePosition = 360 - scale.getValuePosition(getCoercedValue(), false);
if (maximum > minimum) {
if (value > maximum) valuePosition += 8;
else if (value < minimum) valuePosition -= 8;
} else {
if (value > minimum) valuePosition -= 8;
else if (value < maximum) valuePosition += 8;
}
needlePoints.setPoint(
PointsUtil.rotate(needlePoints.getPoint(0), valuePosition, center), 0);
needlePoints.setPoint(
PointsUtil.rotate(needlePoints.getPoint(1), valuePosition, center), 1);
needlePoints.setPoint(
PointsUtil.rotate(needlePoints.getPoint(2), valuePosition, center), 2);
needle.setPoints(needlePoints);
}
// if(needleCenter != null){
// needleCenter.setBounds(new Rectangle(center.x - area.width/4,
// center.y - area.height/4,
// area.width/2, area.height/2));
// }
}
public void layout(IFigure container) {
Rectangle area = container.getClientArea();
area.width = Math.min(area.width, area.height);
area.height = area.width;
area.shrink(BORDER_WIDTH, BORDER_WIDTH);
Point center = area.getCenter();
if (scale != null) {
scale.setBounds(area);
}
if (ramp != null && ramp.isVisible()) {
Rectangle rampBounds = area.getCopy();
ramp.setBounds(rampBounds.shrink(area.width / 4, area.height / 4));
}
if (valueLabel != null) {
Dimension labelSize = valueLabel.getPreferredSize();
valueLabel.setBounds(
new Rectangle(
area.x + area.width / 2 - labelSize.width / 2,
area.y + area.height * 7 / 8 - labelSize.height / 2,
labelSize.width,
labelSize.height));
}
if (needle != null && scale != null) {
needlePoints.setPoint(new Point(center.x, center.y - NeedleCenter.DIAMETER / 2 + 3), 0);
scale.getScaleTickMarks();
needlePoints.setPoint(
new Point(
center.x
+ area.width / 2
- RoundScaleTickMarks.MAJOR_TICK_LENGTH
- GAP_BTW_NEEDLE_SCALE,
center.y),
1);
needlePoints.setPoint(new Point(center.x, center.y + NeedleCenter.DIAMETER / 2 - 3), 2);
double valuePosition = 360 - scale.getValuePosition(getCoercedValue(), false);
if (maximum > minimum) {
if (value > maximum) valuePosition += 10;
else if (value < minimum) valuePosition -= 10;
} else {
if (value > minimum) valuePosition -= 10;
else if (value < maximum) valuePosition += 10;
}
needlePoints.setPoint(
PointsUtil.rotate(needlePoints.getPoint(0), valuePosition, center), 0);
needlePoints.setPoint(
PointsUtil.rotate(needlePoints.getPoint(1), valuePosition, center), 1);
needlePoints.setPoint(
PointsUtil.rotate(needlePoints.getPoint(2), valuePosition, center), 2);
needle.setPoints(needlePoints);
}
if (needleCenter != null) {
needleCenter.setBounds(
new Rectangle(
center.x - NeedleCenter.DIAMETER / 2,
center.y - NeedleCenter.DIAMETER / 2,
NeedleCenter.DIAMETER,
NeedleCenter.DIAMETER));
}
}
@Override
public void execute() {
// configure the request
EditPart source = request.getSourceEditPart();
EditPart target = request.getTargetEditPart();
PointList list = feedback.getPoints();
DiagramEditPart diagramEditPart = null;
if (source.getParent() instanceof DiagramEditPart) {
diagramEditPart = (DiagramEditPart) source.getParent();
} else if (source instanceof DiagramEditPart) {
diagramEditPart = (DiagramEditPart) source;
} else {
if (source.getParent().getParent() instanceof DiagramEditPart) {
diagramEditPart = (DiagramEditPart) source.getParent().getParent();
}
}
if (diagramEditPart == null) {
return;
}
if (!(source instanceof DiagramEditPart || target instanceof DiagramEditPart)) {
// one must be whitespace, we make it the target
request.setTargetEditPart(diagramEditPart);
// additionally we must cut the drawn connection
// in half to share room with the element that will
// be auto-created
PointList newList = new PointList();
newList.addPoint(list.getFirstPoint());
if (list.size() == 4) {
// rectilinear routing will have a three points
newList.addPoint(list.getPoint(1));
}
newList.addPoint(list.getMidpoint());
feedback.setPoints(newList);
}
// create the active tool's element first
CreateConnectionCommand command = new CreateConnectionCommand(request, feedback);
command.execute();
Connector_c newConnector = command.result;
if (newConnector == null) {
return;
}
// we need to now refresh the diagram to get the new edit part
source.refresh();
source.getParent().refresh();
GraphicalEditPart newPart =
(GraphicalEditPart) source.getViewer().getEditPartRegistry().get(newConnector);
// transfer the feedback connection points to the newly created
// edit part
((Connection) newPart.getFigure()).setPoints(feedback.getPoints().getCopy());
// now adjust the request for the new element to be created for each
// terminal specification that requires auto-creation
createElementForTerminalSpec(
autoStartSpec,
((NonRootModelElement) diagramEditPart.getModel()).getModelRoot(),
list,
newPart,
target,
diagramEditPart);
createElementForTerminalSpec(
autoEndSpec,
((NonRootModelElement) diagramEditPart.getModel()).getModelRoot(),
list,
newPart,
target,
diagramEditPart);
}
private void createElementForTerminalSpec(
TerminalSpecification_c autoCreationSpec,
ModelRoot modelRoot,
PointList line,
EditPart newPart,
EditPart targetPart,
final DiagramEditPart diagramEditPart) {
ElementSpecification_c specification =
ElementSpecification_c.getOneGD_ESOnR209(autoCreationSpec);
if (specification != null && request instanceof GraphicsConnectionCreateRequest) {
// deactivate the current tool
ModelTool_c activeTool =
ModelTool_c.ModelToolInstance(
modelRoot,
new ClassQueryInterface_c() {
@Override
public boolean evaluate(Object candidate) {
return ((ModelTool_c) candidate).getActive();
}
});
activeTool.setActive(false);
// find the new tool and activate it
ModelTool_c newTool =
ModelTool_c.getOneCT_MTLOnR103(
specification,
new ClassQueryInterface_c() {
@Override
public boolean evaluate(Object candidate) {
ModelTool_c tool = (ModelTool_c) candidate;
return Model_c.getOneGD_MDOnR100(tool) == diagramEditPart.getModel();
}
});
newTool.setActive(true);
// create the new element
if (specification.getSymboltype().equals("connector")) { // $NON-NLS-1$
// creating a connector
// we want to create the new connector from the
// midpoint of the drawn line to the end of the
// drawn line
PointList newLine = new PointList();
newLine.addPoint(line.getLastPoint());
if (line.size() == 4) {
// rectilinear routing will have a three points
newLine.addPoint(line.getPoint(2));
}
newLine.addPoint(line.getMidpoint());
feedback.setPoints(newLine);
// we also need to adjust the request's source and
// target edit part, we swap the original target as the
// source as if the new connection was drawn from
// the original destination element
request.setTargetEditPart(newPart);
request.setSourceEditPart(targetPart);
// need to update the location in the request for
// those connectors that end on whitespace
request.setLocation(line.getMidpoint());
// we need to configure the proper tool id in the
// request
GraphicsConnectionCreateRequest gRequest = (GraphicsConnectionCreateRequest) request;
gRequest.setToolId(newTool.getTool_id());
CreateConnectionCommand command = new CreateConnectionCommand(request, feedback);
command.disableCropping();
command.execute();
// reset the active tool states
newTool.setActive(false);
activeTool.setActive(true);
} else if (specification.getSymboltype().equals("shape")) { // $NON-NLS-1$
// TODO: support shape auto creation
}
}
// otherwise this is not an auto create specification
}