--- /dev/null
+/*
+ * Copyright (c) 2003, the JUNG Project and the Regents of the University of
+ * California All rights reserved.
+ *
+ * This software is open-source under the BSD license; see either "license.txt"
+ * or http://jung.sourceforge.net/license.txt for a description.
+ *
+ *
+ *
+ */
+package edu.uci.ics.jung.algorithms.layout;
+
+import java.awt.Dimension;
+import java.awt.geom.AffineTransform;
+import java.awt.geom.Point2D;
+import java.util.HashMap;
+import java.util.Map;
+
+import org.apache.commons.collections15.Transformer;
+
+import edu.uci.ics.jung.algorithms.util.IterativeContext;
+import edu.uci.ics.jung.graph.Graph;
+
+/**
+ * A {@code Layout} implementation that combines
+ * multiple other layouts so that they may be manipulated
+ * as one layout. The relaxer thread will step each layout
+ * in sequence.
+ *
+ * @author Tom Nelson - tomnelson@dev.java.net
+ *
+ * @param <V> the vertex type
+ * @param <E> the edge type
+ */
+public class AggregateLayout<V, E> implements Layout<V,E>, IterativeContext {
+
+ protected Layout<V,E> delegate;
+ protected Map<Layout<V,E>,Point2D> layouts = new HashMap<Layout<V,E>,Point2D>();
+
+ /**
+ * Creates an instance backed by the specified {@code delegate}.
+ * @param delegate
+ */
+ public AggregateLayout(Layout<V, E> delegate) {
+ this.delegate = delegate;
+ }
+
+ /**
+ * @return the delegate
+ */
+ public Layout<V, E> getDelegate() {
+ return delegate;
+ }
+
+ /**
+ * @param delegate the delegate to set
+ */
+ public void setDelegate(Layout<V, E> delegate) {
+ this.delegate = delegate;
+ }
+
+ /**
+ * adds the passed layout as a sublayout, also specifying
+ * the center of where this sublayout should appear
+ * @param layout
+ * @param center
+ */
+ public void put(Layout<V,E> layout, Point2D center) {
+ layouts.put(layout,center);
+ }
+
+ /**
+ * Returns the center of the passed layout.
+ * @param layout
+ * @return the center of the passed layout
+ */
+ public Point2D get(Layout<V,E> layout) {
+ return layouts.get(layout);
+ }
+
+ /**
+ * Removes {@code layout} from this instance.
+ */
+ public void remove(Layout<V,E> layout) {
+ layouts.remove(layout);
+ }
+
+ /**
+ * Removes all layouts from this instance.
+ */
+ public void removeAll() {
+ layouts.clear();
+ }
+
+ /**
+ * Returns the graph for which this layout is defined.
+ * @return the graph for which this layout is defined
+ * @see edu.uci.ics.jung.algorithms.layout.Layout#getGraph()
+ */
+ public Graph<V, E> getGraph() {
+ return delegate.getGraph();
+ }
+
+ /**
+ * Returns the size of the underlying layout.
+ * @return the size of the underlying layout
+ * @see edu.uci.ics.jung.algorithms.layout.Layout#getSize()
+ */
+ public Dimension getSize() {
+ return delegate.getSize();
+ }
+
+ /**
+ *
+ * @see edu.uci.ics.jung.algorithms.layout.Layout#initialize()
+ */
+ public void initialize() {
+ delegate.initialize();
+ for(Layout<V,E> layout : layouts.keySet()) {
+ layout.initialize();
+ }
+ }
+
+ /**
+ * Override to test if the passed vertex is locked in
+ * any of the layouts.
+ * @param v
+ * @return true if v is locked in any of the layouts, and false otherwise
+ * @see edu.uci.ics.jung.algorithms.layout.Layout#isLocked(java.lang.Object)
+ */
+ public boolean isLocked(V v) {
+ boolean locked = false;
+ for(Layout<V,E> layout : layouts.keySet()) {
+ locked |= layout.isLocked(v);
+ }
+ locked |= delegate.isLocked(v);
+ return locked;
+ }
+
+ /**
+ * override to lock or unlock this vertex in any layout with
+ * a subgraph containing it
+ * @param v
+ * @param state
+ * @see edu.uci.ics.jung.algorithms.layout.Layout#lock(java.lang.Object, boolean)
+ */
+ public void lock(V v, boolean state) {
+ for(Layout<V,E> layout : layouts.keySet()) {
+ if(layout.getGraph().getVertices().contains(v)) {
+ layout.lock(v, state);
+ }
+ }
+ delegate.lock(v, state);
+ }
+
+ /**
+ *
+ * @see edu.uci.ics.jung.algorithms.layout.Layout#reset()
+ */
+ public void reset() {
+ for(Layout<V,E> layout : layouts.keySet()) {
+ layout.reset();
+ }
+ delegate.reset();
+ }
+
+ /**
+ * @param graph
+ * @see edu.uci.ics.jung.algorithms.layout.Layout#setGraph(edu.uci.ics.jung.graph.Graph)
+ */
+ public void setGraph(Graph<V, E> graph) {
+ delegate.setGraph(graph);
+ }
+
+ /**
+ * @param initializer
+ * @see edu.uci.ics.jung.algorithms.layout.Layout#setInitializer(org.apache.commons.collections15.Transformer)
+ */
+ public void setInitializer(Transformer<V, Point2D> initializer) {
+ delegate.setInitializer(initializer);
+ }
+
+ /**
+ * @param v
+ * @param location
+ * @see edu.uci.ics.jung.algorithms.layout.Layout#setLocation(java.lang.Object, java.awt.geom.Point2D)
+ */
+ public void setLocation(V v, Point2D location) {
+ boolean wasInSublayout = false;
+ for(Layout<V,E> layout : layouts.keySet()) {
+ if(layout.getGraph().getVertices().contains(v)) {
+ Point2D center = layouts.get(layout);
+ // transform by the layout itself, but offset to the
+ // center of the sublayout
+ Dimension d = layout.getSize();
+
+ AffineTransform at =
+ AffineTransform.getTranslateInstance(-center.getX()+d.width/2,-center.getY()+d.height/2);
+ Point2D localLocation = at.transform(location, null);
+ layout.setLocation(v, localLocation);
+ wasInSublayout = true;
+ }
+ }
+ if(wasInSublayout == false && getGraph().getVertices().contains(v)) {
+ delegate.setLocation(v, location);
+ }
+ }
+
+ /**
+ * @param d
+ * @see edu.uci.ics.jung.algorithms.layout.Layout#setSize(java.awt.Dimension)
+ */
+ public void setSize(Dimension d) {
+ delegate.setSize(d);
+ }
+
+ /**
+ * Returns a map from each {@code Layout} instance to its center point.
+ */
+ public Map<Layout<V,E>,Point2D> getLayouts() {
+ return layouts;
+ }
+
+ /**
+ * Returns the location of the vertex. The location is specified first
+ * by the sublayouts, and then by the base layout if no sublayouts operate
+ * on this vertex.
+ * @return the location of the vertex
+ * @see org.apache.commons.collections15.Transformer#transform(java.lang.Object)
+ */
+ public Point2D transform(V v) {
+ boolean wasInSublayout = false;
+ for(Layout<V,E> layout : layouts.keySet()) {
+ if(layout.getGraph().getVertices().contains(v)) {
+ wasInSublayout = true;
+ Point2D center = layouts.get(layout);
+ // transform by the layout itself, but offset to the
+ // center of the sublayout
+ Dimension d = layout.getSize();
+ AffineTransform at =
+ AffineTransform.getTranslateInstance(center.getX()-d.width/2,
+ center.getY()-d.height/2);
+ return at.transform(layout.transform(v),null);
+ }
+ }
+ if(wasInSublayout == false) {
+ return delegate.transform(v);
+ }
+ return null;
+
+ }
+
+ /**
+ * Check all sublayouts.keySet() and the delegate layout, returning
+ * done == true iff all are done.
+ */
+ public boolean done() {
+ boolean done = true;
+ for(Layout<V,E> layout : layouts.keySet()) {
+ if(layout instanceof IterativeContext) {
+ done &= ((IterativeContext)layout).done();
+ }
+ }
+ if(delegate instanceof IterativeContext) {
+ done &= ((IterativeContext)delegate).done();
+ }
+ return done;
+ }
+
+ /**
+ * call step on any sublayout that is also an IterativeContext
+ * and is not done
+ */
+ public void step() {
+ for(Layout<V,E> layout : layouts.keySet()) {
+ if(layout instanceof IterativeContext) {
+ IterativeContext context = (IterativeContext)layout;
+ if(context.done() == false) {
+ context.step();
+ }
+ }
+ }
+ if(delegate instanceof IterativeContext) {
+ IterativeContext context = (IterativeContext)delegate;
+ if(context.done() == false) {
+ context.step();
+ }
+ }
+ }
+
+}
Code Review / controller.git / blobdiff