Mercurial > projects > dwt2
view org.eclipse.draw2d/src/org/eclipse/draw2d/ShortestPathConnectionRouter.d @ 125:c43718956f21 default tip
Updated the snippets status.
author | Jacob Carlborg <doob@me.com> |
---|---|
date | Thu, 11 Aug 2011 19:55:14 +0200 |
parents | dbfb303e8fb0 |
children |
line wrap: on
line source
/******************************************************************************* * Copyright (c) 2000, 2005 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 * Port to the D programming language: * Frank Benoit <benoit@tionex.de> *******************************************************************************/ module org.eclipse.draw2d.ShortestPathConnectionRouter; import java.lang.all; import java.util.Collections; import java.util.HashSet; import java.util.HashMap; import java.util.Set; import java.util.Iterator; import java.util.List; import java.util.Map; import org.eclipse.draw2d.geometry.Point; import org.eclipse.draw2d.geometry.PointList; import org.eclipse.draw2d.geometry.PrecisionPoint; import org.eclipse.draw2d.geometry.Rectangle; import org.eclipse.draw2d.graph.Path; import org.eclipse.draw2d.graph.ShortestPathRouter; import org.eclipse.draw2d.AbstractRouter; import org.eclipse.draw2d.IFigure; import org.eclipse.draw2d.LayoutListener; import org.eclipse.draw2d.FigureListener; import org.eclipse.draw2d.Connection; import org.eclipse.draw2d.Bendpoint; /** * Routes multiple connections around the children of a given container figure. * @author Whitney Sorenson * @author Randy Hudson * @since 3.1 */ public final class ShortestPathConnectionRouter : AbstractRouter { private class LayoutTracker : LayoutListenerStub { public void postLayout(IFigure container) { processLayout(); } public void remove(IFigure child) { removeChild(child); } public void setConstraint(IFigure child, Object constraint) { addChild(child); } } private Map constraintMap; private Map figuresToBounds; private Map connectionToPaths; private bool isDirty; private ShortestPathRouter algorithm; private IFigure container; private Set staleConnections; private LayoutListener listener; private FigureListener figureListener; private void initFigureListener(){ figureListener = new class() FigureListener { public void figureMoved(IFigure source) { Rectangle newBounds = source.getBounds().getCopy(); if (algorithm.updateObstacle(cast(Rectangle)figuresToBounds.get(cast(Object)source), newBounds)) { queueSomeRouting(); isDirty = true; } figuresToBounds.put(cast(Object)source, newBounds); } }; } private bool ignoreInvalidate; /** * Creates a new shortest path router with the given container. The container * contains all the figure's which will be treated as obstacles for the connections to * avoid. Any time a child of the container moves, one or more connections will be * revalidated to process the new obstacle locations. The connections being routed must * not be contained within the container. * * @param container the container */ public this(IFigure container) { initFigureListener(); constraintMap = new HashMap(); algorithm = new ShortestPathRouter(); staleConnections = new HashSet(); listener = new LayoutTracker(); isDirty = false; algorithm = new ShortestPathRouter(); this.container = container; } void addChild(IFigure child) { if (connectionToPaths is null) return; if (figuresToBounds.containsKey(cast(Object)child)) return; Rectangle bounds = child.getBounds().getCopy(); algorithm.addObstacle(bounds); figuresToBounds.put(cast(Object)child, bounds); child.addFigureListener(figureListener); isDirty = true; } private void hookAll() { figuresToBounds = new HashMap(); for (int i = 0; i < container.getChildren().size(); i++) addChild(cast(IFigure)container.getChildren().get(i)); container.addLayoutListener(listener); } private void unhookAll() { container.removeLayoutListener(listener); if (figuresToBounds !is null) { Iterator figureItr = figuresToBounds.keySet().iterator(); while (figureItr.hasNext()) { //Must use iterator's remove to avoid concurrent modification IFigure child = cast(IFigure)figureItr.next(); figureItr.remove(); removeChild(child); } figuresToBounds = null; } } /** * Gets the constraint for the given {@link Connection}. The constraint is the paths * list of bend points for this connection. * * @param connection The connection whose constraint we are retrieving * @return The constraint */ public Object getConstraint(Connection connection) { return constraintMap.get(cast(Object)connection); } /** * Returns the default spacing maintained on either side of a connection. The default * value is 4. * @return the connection spacing * @since 3.2 */ public int getSpacing() { return algorithm.getSpacing(); } /** * @see ConnectionRouter#invalidate(Connection) */ public void invalidate(Connection connection) { if (ignoreInvalidate) return; staleConnections.add(cast(Object)connection); isDirty = true; } private void processLayout() { if (staleConnections.isEmpty()) return; (cast(Connection)staleConnections.iterator().next()).revalidate(); } private void processStaleConnections() { Iterator iter = staleConnections.iterator(); if (iter.hasNext() && connectionToPaths is null) { connectionToPaths = new HashMap(); hookAll(); } while (iter.hasNext()) { Connection conn = cast(Connection)iter.next(); Path path = cast(Path)connectionToPaths.get(cast(Object)conn); if (path is null) { path = new Path(cast(Object)conn); connectionToPaths.put(cast(Object)conn, path); algorithm.addPath(path); } List constraint = cast(List)getConstraint(conn); if (constraint is null) constraint = Collections.EMPTY_LIST; Point start = conn.getSourceAnchor().getReferencePoint().getCopy(); Point end = conn.getTargetAnchor().getReferencePoint().getCopy(); container.translateToRelative(start); container.translateToRelative(end); path.setStartPoint(start); path.setEndPoint(end); if (!constraint.isEmpty()) { PointList bends = new PointList(constraint.size()); for (int i = 0; i < constraint.size(); i++) { Bendpoint bp = cast(Bendpoint)constraint.get(i); bends.addPoint(bp.getLocation()); } path.setBendPoints(bends); } else path.setBendPoints(null); isDirty |= path.isDirty; } staleConnections.clear(); } void queueSomeRouting() { if (connectionToPaths is null || connectionToPaths.isEmpty()) return; try { ignoreInvalidate = true; (cast(Connection)connectionToPaths.keySet().iterator().next()) .revalidate(); } finally { ignoreInvalidate = false; } } /** * @see ConnectionRouter#remove(Connection) */ public void remove(Connection connection) { staleConnections.remove(cast(Object)connection); constraintMap.remove(cast(Object)connection); if (connectionToPaths is null) return; Path path = cast(Path)connectionToPaths.remove(cast(Object)connection); algorithm.removePath(path); isDirty = true; if (connectionToPaths.isEmpty()) { unhookAll(); connectionToPaths = null; } else { //Make sure one of the remaining is revalidated so that we can re-route again. queueSomeRouting(); } } void removeChild(IFigure child) { if (connectionToPaths is null) return; Rectangle bounds = child.getBounds().getCopy(); bool change = algorithm.removeObstacle(bounds); figuresToBounds.remove(cast(Object)child); child.removeFigureListener(figureListener); if (change) { isDirty = true; queueSomeRouting(); } } /** * @see ConnectionRouter#route(Connection) */ 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 = cast(Path) updated.get(i); current = cast(Connection)path.data; current.revalidate(); PointList points = path.getPoints().getCopy(); Point ref1, ref2, start, 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; } } /** * @see ConnectionRouter#setConstraint(Connection, Object) */ public void setConstraint(Connection connection, Object constraint) { //Connection.setConstraint() already calls revalidate, so we know that a // route() call will follow. staleConnections.add(cast(Object)connection); constraintMap.put(cast(Object)connection, constraint); isDirty = true; } /** * Sets the default space that should be maintained on either side of a connection. This * causes the connections to be separated from each other and from the obstacles. The * default value is 4. * * @param spacing the connection spacing * @since 3.2 */ public void setSpacing(int spacing) { algorithm.setSpacing(spacing); } }