/*
* Copyright (c) 2003, The JUNG Authors
* All rights reserved.
*
* This software is open-source under the BSD license; see either "license.txt"
* or https://github.com/jrtom/jung/blob/master/LICENSE 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 com.google.common.base.Function;
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 the vertex type
* @param the edge type
*/
public class AggregateLayout implements Layout, IterativeContext {
protected Layout delegate;
protected Map,Point2D> layouts = new HashMap,Point2D>();
/**
* Creates an instance backed by the specified {@code delegate}.
* @param delegate the layout to which this instance is delegating
*/
public AggregateLayout(Layout delegate) {
this.delegate = delegate;
}
/**
* @return the delegate
*/
public Layout getDelegate() {
return delegate;
}
/**
* @param delegate the delegate to set
*/
public void setDelegate(Layout delegate) {
this.delegate = delegate;
}
/**
* Adds the passed layout as a sublayout, and specifies
* the center of where this sublayout should appear.
* @param layout the layout algorithm to use as a sublayout
* @param center the center of the coordinates for the sublayout
*/
public void put(Layout layout, Point2D center) {
layouts.put(layout,center);
}
/**
* @param layout the layout whose center is to be returned
* @return the center of the passed layout
*/
public Point2D get(Layout layout) {
return layouts.get(layout);
}
/**
* Removes {@code layout} from this instance.
* @param layout the layout to remove
*/
public void remove(Layout layout) {
layouts.remove(layout);
}
/**
* Removes all layouts from this instance.
*/
public void removeAll() {
layouts.clear();
}
public Graph getGraph() {
return delegate.getGraph();
}
public Dimension getSize() {
return delegate.getSize();
}
public void initialize() {
delegate.initialize();
for(Layout layout : layouts.keySet()) {
layout.initialize();
}
}
/**
* @param v the vertex whose locked state is to be returned
* @return true if v is locked in any of the layouts, and false otherwise
*/
public boolean isLocked(V v) {
for(Layout layout : layouts.keySet()) {
if (layout.isLocked(v)) {
return true;
}
}
return delegate.isLocked(v);
}
/**
* Locks this vertex in the main layout and in any sublayouts whose graph contains
* this vertex.
* @param v the vertex whose locked state is to be set
* @param state {@code true} if the vertex is to be locked, and {@code false} if unlocked
*/
public void lock(V v, boolean state) {
for(Layout layout : layouts.keySet()) {
if(layout.getGraph().getVertices().contains(v)) {
layout.lock(v, state);
}
}
delegate.lock(v, state);
}
public void reset() {
for(Layout layout : layouts.keySet()) {
layout.reset();
}
delegate.reset();
}
public void setGraph(Graph graph) {
delegate.setGraph(graph);
}
public void setInitializer(Function initializer) {
delegate.setInitializer(initializer);
}
public void setLocation(V v, Point2D location) {
boolean wasInSublayout = false;
for(Layout 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);
}
}
public void setSize(Dimension d) {
delegate.setSize(d);
}
/**
* @return a map from each {@code Layout} instance to its center point.
*/
public Map,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
*/
public Point2D apply(V v) {
boolean wasInSublayout = false;
for(Layout 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.apply(v),null);
}
}
if(wasInSublayout == false) {
return delegate.apply(v);
}
return null;
}
/**
* @return {@code true} iff the delegate layout and all sublayouts are done
*/
public boolean done() {
for (Layout layout : layouts.keySet()) {
if (layout instanceof IterativeContext) {
if (! ((IterativeContext) layout).done() ) {
return false;
}
}
}
if(delegate instanceof IterativeContext) {
return ((IterativeContext)delegate).done();
}
return true;
}
/**
* Call step on any sublayout that is also an IterativeContext and is not done
*/
public void step() {
for(Layout 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();
}
}
}
}
Ads help maintain this website.