/*******************************************************************************
* Copyright (c) 2000, 2012 IBM Corporation 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:
* IBM Corporation - initial API and implementation
* SAP AG - Changed for initial API, implementation and documentation of Graphiti:
* added getBounds
* added getSourceDecorations
* added getTargetDecorations
* added setSourceDecorations
* added setTargetDecorations
* removed getMaxValue
* added override tags
* mwenz - Bug 352440 - Fixed deprecation warnings - contributed by Felix Velasco
* mgorning - Bug 378301 - Small gap between connections and right side anchor
*
*******************************************************************************/
package org.eclipse.graphiti.ui.internal.figures;
import java.util.ArrayList;
import java.util.List;
import org.eclipse.draw2d.AnchorListener;
import org.eclipse.draw2d.Connection;
import org.eclipse.draw2d.ConnectionAnchor;
import org.eclipse.draw2d.ConnectionRouter;
import org.eclipse.draw2d.DelegatingLayout;
import org.eclipse.draw2d.Figure;
import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.RoutingListener;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PointList;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.graphiti.mm.algorithms.GraphicsAlgorithm;
import org.eclipse.graphiti.ui.internal.parts.IPictogramElementDelegate;
/**
* A Graphiti Polyline Connection. The "polyline functionality" is inherited
* from the super-class, the "connection functionality" is added in this class.
* <p>
* Important difference: The super-class denotes a polyline-shape. There the
* points are translated towards the center depending on the line-width, so that
* the bounds of the polyline-shape are only dependent on the points of the
* polyline but not on the current line-width. Otherwise it would be difficult
* to align its positions/sizes with the neighbor-shapes or parent-shapes. This
* class on the other hand denotes a polyline-connection. Here the points are
* not translated towards the center, because the polyline must always go
* directly through the given points.
*
* @noinstantiate This class is not intended to be instantiated by clients.
* @noextend This class is not intended to be subclassed by clients.
*/
public class GFPolylineConnection extends GFPolyline implements Connection, AnchorListener {
/**
* Creates a new GFPolylineConnection.
*
* @param pictogramElementDelegate
* The PictogramElementDelegate which provides the
* GraphicsAlgorithm.
* @param graphicsAlgorithm
* The GraphicsAlgorithm which provides the values to paint this
* Shape.
*/
public GFPolylineConnection(IPictogramElementDelegate pictogramElementDelegate, GraphicsAlgorithm graphicsAlgorithm) {
super(pictogramElementDelegate, graphicsAlgorithm);
// by default the connections are drawn as rounded bezier-curves
setGeneralBezierDistance(15);
}
/**
* Returns a new instance of the input point-list, which is adjusted
* regarding the given zoom-factor and line-width.
* <p>
* The implementation only zooms the points regarding the zoom-factor. It
* does not translate the points towards the center depending on the
* line-width. See explanation in the javadoc of this class.
*
* @param points
* The point-list which to adjust.
* @param zoom
* The zoom-factor to regard.
* @param lw
* The line-width to regard.
*/
@Override
protected PointList getAdjustedPointList(PointList points, double zoom, double lw) {
// only zoom, but do not translate regarding the line-width as the
// super-class
// copy the point list
PointList pointsCopy = new PointList();
pointsCopy.addAll(points);
// adjust both end points if necessary; see Bug 378301
// it seems there is a problem if we draw a line to an end point from
// left to right or up to bottom. The last point will not be drawn and
// hence there is a gap between the connection and the shape. Especially
// if zoom is greater then 100%.
if (pointsCopy.size() >= 2) {
// check end points and adjust them if necessary
int lastPointIndex = pointsCopy.size() - 1;
adjustEndPoint(pointsCopy, 0, 1);
adjustEndPoint(pointsCopy, lastPointIndex, lastPointIndex - 1);
}
// handle zoom
PointList ret = new PointList();
for (int i = 0; i < pointsCopy.size(); i++) {
Point point = pointsCopy.getPoint(i);
point.scale(zoom);
ret.addPoint(point);
}
return ret;
}
/**
* Returns the bounds which holds all the points in this polyline
* connection. Note, that the childrens bounds are also added to the
* super-class bounds.
* <p>
* The implementation adds the half line-width to the bounds of the
* super-class, because the points are not translated towards the center
* (see {@link #getAdjustedPointList(PointList, double, double)}), so that
* bounds must expand depending on the line-width.
*
* @return The bounds which holds all the points in this polyline
* connection.
*/
@Override
public Rectangle getBounds() {
if (bounds == null) {
super.getBounds();
int halfLineWidth = getLineWidth() / 2;
bounds.expand(halfLineWidth, halfLineWidth);
for (int i = 0; i < getChildren().size(); i++) {
IFigure child = (IFigure) getChildren().get(i);
bounds.union(child.getBounds());
}
}
return bounds;
}
@Override
protected List<BezierPoint> getBezierPoints(PointList points, double zoom) {
List<BezierPoint> ret = new ArrayList<BezierPoint>(points.size());
if (getSpecificBezierDistances() != null && (points.size() == getSpecificBezierDistances().length / 2)) {
for (int i = 0; i < points.size(); i++) {
int bezierDistanceBefore = (int) (getSpecificBezierDistances()[2 * i] * zoom);
int bezierDistanceAfter = (int) (getSpecificBezierDistances()[2 * i + 1] * zoom);
Point point = points.getPoint(i);
ret.add(new BezierPoint(point.x, point.y, bezierDistanceBefore, bezierDistanceAfter));
}
} else {
// special case if we create or remove a bendpoint
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;
}
@Override
public void setSpecificBezierDistances(int[] bezierDistances) {
super.setSpecificBezierDistances(bezierDistances);
setGeneralBezierDistance(getMaxValue(bezierDistances));
}
// /////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////
// the following code is copied from PolylineConnection //
// (changed: added @Override tags) //
// (changed: made methods getXXXDecoration() public) //
// /////////////////////////////////////////////////////////////////////////
// /////////////////////////////////////////////////////////////////////////
private ConnectionAnchor startAnchor, endAnchor;
private ConnectionRouter connectionRouter = ConnectionRouter.NULL;
/**
* A list of all decorations, which are currently added to this connection.
*/
private List<IFigure> decorations = new ArrayList<IFigure>();
{
setLayoutManager(new DelegatingLayout());
addPoint(new Point(0, 0));
addPoint(new Point(100, 100));
}
/**
* Hooks the source and target anchors.
*
* @see Figure#addNotify()
*/
@Override
public void addNotify() {
super.addNotify();
hookSourceAnchor();
hookTargetAnchor();
}
/**
* Appends the given routing listener to the list of listeners.
*
* @param listener
* the routing listener
* @since 3.2
*/
public void addRoutingListener(RoutingListener listener) {
if (connectionRouter instanceof RoutingNotifier) {
RoutingNotifier notifier = (RoutingNotifier) connectionRouter;
notifier.listeners.add(listener);
} else
connectionRouter = new RoutingNotifier(connectionRouter, listener);
}
/**
* Called by the anchors of this connection when they have moved,
* revalidating this polyline connection.
*
* @param anchor
* the anchor that moved
*/
public void anchorMoved(ConnectionAnchor anchor) {
revalidate();
}
/**
* Returns the <code>ConnectionRouter</code> used to layout this connection.
* Will not return <code>null</code>.
*
* @return this connection's router
*/
public ConnectionRouter getConnectionRouter() {
if (connectionRouter instanceof RoutingNotifier)
return ((RoutingNotifier) connectionRouter).realRouter;
return connectionRouter;
}
/**
* Returns this connection's routing constraint from its connection router.
* May return <code>null</code>.
*
* @return the connection's routing constraint
*/
public Object getRoutingConstraint() {
if (getConnectionRouter() != null)
return getConnectionRouter().getConstraint(this);
else
return null;
}
/**
* @return the anchor at the start of this polyline connection (may be null)
*/
public ConnectionAnchor getSourceAnchor() {
return startAnchor;
}
/**
* @return the anchor at the end of this polyline connection (may be null)
*/
public ConnectionAnchor getTargetAnchor() {
return endAnchor;
}
private void hookSourceAnchor() {
if (getSourceAnchor() != null)
getSourceAnchor().addAnchorListener(this);
}
private void hookTargetAnchor() {
if (getTargetAnchor() != null)
getTargetAnchor().addAnchorListener(this);
}
/**
* Layouts this polyline. If the start and end anchors are present, the
* connection router is used to route this, after which it is laid out. It
* also fires a moved method.
*/
@Override
public void layout() {
if (getSourceAnchor() != null && getTargetAnchor() != null)
connectionRouter.route(this);
Rectangle oldBounds = bounds;
super.layout();
bounds = null;
if (!getBounds().contains(oldBounds)) {
getParent().translateToParent(oldBounds);
getUpdateManager().addDirtyRegion(getParent(), oldBounds);
}
repaint();
fireFigureMoved();
}
/**
* Called just before the receiver is being removed from its parent. Results
* in removing itself from the connection router.
*
* @since 2.0
*/
@Override
public void removeNotify() {
unhookSourceAnchor();
unhookTargetAnchor();
connectionRouter.remove(this);
super.removeNotify();
}
/**
* Removes the first occurence of the given listener.
*
* @param listener
* the listener being removed
* @since 3.2
*/
public void removeRoutingListener(RoutingListener listener) {
if (connectionRouter instanceof RoutingNotifier) {
RoutingNotifier notifier = (RoutingNotifier) connectionRouter;
notifier.listeners.remove(listener);
if (notifier.listeners.isEmpty())
connectionRouter = notifier.realRouter;
}
}
/**
* @see IFigure#revalidate()
*/
@Override
public void revalidate() {
super.revalidate();
connectionRouter.invalidate(this);
}
/**
* Sets the connection router which handles the layout of this polyline.
* Generally set by the parent handling the polyline connection.
*
* @param cr
* the connection router
*/
public void setConnectionRouter(ConnectionRouter cr) {
if (cr == null)
cr = ConnectionRouter.NULL;
ConnectionRouter oldRouter = getConnectionRouter();
if (oldRouter != cr) {
connectionRouter.remove(this);
if (connectionRouter instanceof RoutingNotifier)
((RoutingNotifier) connectionRouter).realRouter = cr;
else
connectionRouter = cr;
firePropertyChange(Connection.PROPERTY_CONNECTION_ROUTER, oldRouter, cr);
revalidate();
}
}
/**
* Sets the routing constraint for this connection.
*
* @param cons
* the constraint
*/
public void setRoutingConstraint(Object cons) {
if (connectionRouter != null)
connectionRouter.setConstraint(this, cons);
revalidate();
}
/**
* Sets the anchor to be used at the start of this polyline connection.
*
* @param anchor
* the new source anchor
*/
public void setSourceAnchor(ConnectionAnchor anchor) {
if (anchor == startAnchor)
return;
unhookSourceAnchor();
// No longer needed, revalidate does this.
// getConnectionRouter().invalidate(this);
startAnchor = anchor;
if (getParent() != null)
hookSourceAnchor();
revalidate();
}
/**
* Adds a decoration to this connection. The decoration is located depending
* on the distance values.
*
* @param decoration
* The decoration to add.
* @param distanceToStart
* If the distance values refer to the start-point or the
* end-point. See {@link FlexibleRotatableLocator}.
* @param relativeDistance
* The relative distance. See {@link FlexibleRotatableLocator}.
* @param absoluteDistance
* The absolute distance. See {@link FlexibleRotatableLocator}.
* @param rotateDegrees
* The rotation in degrees. See {@link FlexibleRotatableLocator}.
*/
public void addDecoration(IFigure decoration, boolean distanceToStart, double relativeDistance,
int absoluteDistance, double rotateDegrees) {
if (decoration != null) {
// remove if decoration was added before
boolean removed = decorations.remove(decoration);
if (removed) { // was added before
remove(decoration);
}
// add decoration
decorations.add(decoration);
add(decoration, new FlexibleRotatableLocator(this, distanceToStart, relativeDistance, absoluteDistance,
rotateDegrees));
}
}
/**
* Removes all currently added decorations from the connection.
*
* @see #getAllDecorations()
*/
public void removeAllDecorations() {
for (IFigure decoration : decorations) {
remove(decoration);
}
decorations.clear();
}
/**
* Returns a list of all decorations, which are currently added to this
* connection. Can be empty but not null.
*
* @return A list of all decorations, which are currently added to this
* connection.
* @see #addDecoration(IFigure, boolean, double, int)
*/
public List<IFigure> getAllDecorations() {
return decorations;
}
/**
* Sets the anchor to be used at the end of the polyline connection. Removes
* this listener from the old anchor and adds it to the new anchor.
*
* @param anchor
* the new target anchor
*/
public void setTargetAnchor(ConnectionAnchor anchor) {
if (anchor == endAnchor)
return;
unhookTargetAnchor();
// No longer needed, revalidate does this.
// getConnectionRouter().invalidate(this);
endAnchor = anchor;
if (getParent() != null)
hookTargetAnchor();
revalidate();
}
private void unhookSourceAnchor() {
if (getSourceAnchor() != null)
getSourceAnchor().removeAnchorListener(this);
}
private void unhookTargetAnchor() {
if (getTargetAnchor() != null)
getTargetAnchor().removeAnchorListener(this);
}
final class RoutingNotifier implements ConnectionRouter {
ConnectionRouter realRouter;
List<RoutingListener> listeners = new ArrayList<RoutingListener>(1);
RoutingNotifier(ConnectionRouter router, RoutingListener listener) {
realRouter = router;
listeners.add(listener);
}
public Object getConstraint(Connection connection) {
return realRouter.getConstraint(connection);
}
public void invalidate(Connection connection) {
for (int i = 0; i < listeners.size(); i++)
listeners.get(i).invalidate(connection);
realRouter.invalidate(connection);
}
public void route(Connection connection) {
boolean consumed = false;
for (int i = 0; i < listeners.size(); i++)
consumed |= listeners.get(i).route(connection);
if (!consumed)
realRouter.route(connection);
for (int i = 0; i < listeners.size(); i++)
listeners.get(i).postRoute(connection);
}
public void remove(Connection connection) {
for (int i = 0; i < listeners.size(); i++)
listeners.get(i).remove(connection);
realRouter.remove(connection);
}
public void setConstraint(Connection connection, Object constraint) {
for (int i = 0; i < listeners.size(); i++)
listeners.get(i).setConstraint(connection, constraint);
realRouter.setConstraint(connection, constraint);
}
}
private int getMaxValue(int[] numbers) {
int maxValue = numbers[0];
for (int i = 1; i < numbers.length; i++) {
if (numbers[i] > maxValue) {
maxValue = numbers[i];
}
}
return maxValue;
}
private void adjustEndPoint(PointList pointsCopy, int endPointIndex, int previousPointIndex) {
Point endPoint = pointsCopy.getPoint(endPointIndex);
Point previousPoint = pointsCopy.getPoint(previousPointIndex);
if (endPoint.x > previousPoint.x) {
endPoint.x += 1;
pointsCopy.setPoint(endPoint, endPointIndex);
}
if (endPoint.y > previousPoint.y) {
endPoint.y += 1;
pointsCopy.setPoint(endPoint, endPointIndex);
}
}
}