Attachment #141333 for bug #283179

View | Details | Raw Unified | Return to bug 283179
Collapse All | Expand All




/*******************************************************************************
 * Copyright 2005-2009, CHISEL Group, University of Victoria, Victoria, BC,
 * Canada. 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:
 *     The Chisel Group, University of Victoria
 *     Mateusz Matela <mateusz.matela@gmail.com> - Adapt Zest to changes in layout - https://bugs.eclipse.org/bugs/show_bug.cgi?id=283179
 ******************************************************************************/
package org.eclipse.zest.core.viewers.internal;


import org.eclipse.zest.core.viewers.AbstractZoomableViewer;
import org.eclipse.zest.core.viewers.IGraphContentProvider;
import org.eclipse.zest.core.widgets.CGraphNode;
import org.eclipse.zest.core.widgets.ConstraintAdapter;
import org.eclipse.zest.core.widgets.Graph;
import org.eclipse.zest.core.widgets.GraphConnection;
import org.eclipse.zest.core.widgets.GraphContainer;
import org.eclipse.zest.core.widgets.GraphItem;
import org.eclipse.zest.core.widgets.GraphNode;
import org.eclipse.zest.core.widgets.IContainer;
import org.eclipse.zest.core.widgets.ZestStyles;
import org.eclipse.zest.layouts.LayoutAlgorithm;

/**
 * Abstraction of graph viewers to implement functionality used by all of them.
 * Not intended to be implemented by clients. Use one of the provided children
 * instead.

	private HashMap connectionsMap = new HashMap();

	/**
	 * The constraint adatpers
	 */
	private List constraintAdapters = new ArrayList();

	/**
	 * A simple graph comparator that orders graph elements based on thier type
	 * (connection or node), and their unique object identification.
	 */

	}

	/**
	 * Adds a new constraint adapter to the list of constraints
	 * 
	 * @param constraintAdapter
	 */
	public void addConstraintAdapter(ConstraintAdapter constraintAdapter) {
		this.constraintAdapters.add(constraintAdapter);
	}

	/**
	 * Gets all the constraint adapters currently on the viewer
	 * 
	 * @return
	 */
	public List getConstraintAdapters() {
		return this.constraintAdapters;
	}

	/**
	 * Sets the layout algorithm for this viewer. Subclasses may place
	 * restrictions on the algorithms that it accepts.
	 * 

		return node;
	}

	GraphNode addGraphModelNode(GraphContainer container, Object element) {
		GraphNode node = this.getGraphModelNode(element);
		if (node == null) {
			node = new GraphNode(container, SWT.NONE);

		GraphConnection relationship = (GraphConnection) connectionsMap.get(connection);

		if (relationship != null) {
			// remove the relationship from the layout algorithm
			if (getLayoutAlgorithm() != null) {
				getLayoutAlgorithm().removeRelationship(relationship.getLayoutRelationship());
			}
			// remove the relationship from the model
			relationship.dispose();
		}

		GraphNode node = (GraphNode) nodesMap.get(element);

		if (node != null) {
			// remove the node from the layout algorithm and all the connections
			if (getLayoutAlgorithm() != null) {
				getLayoutAlgorithm().removeEntity(node.getLayoutEntity());
				getLayoutAlgorithm().removeRelationships(node.getSourceConnections());
				getLayoutAlgorithm().removeRelationships(node.getTargetConnections());
			}
			// remove the node and it's connections from the model
			node.dispose();
		}




/*******************************************************************************
 * Copyright 2005-2009, CHISEL Group, University of Victoria, Victoria, BC,
 * Canada. 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:
 *     The Chisel Group, University of Victoria
 *     Mateusz Matela <mateusz.matela@gmail.com> - Adapt Zest to changes in layout - https://bugs.eclipse.org/bugs/show_bug.cgi?id=283179
 ******************************************************************************/
package org.eclipse.zest.core.viewers.internal;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;

import org.eclipse.zest.core.viewers.INestedContentProvider;
import org.eclipse.zest.core.widgets.Graph;
import org.eclipse.zest.core.widgets.GraphConnection;
import org.eclipse.zest.core.widgets.GraphContainer;
import org.eclipse.zest.core.widgets.GraphItem;
import org.eclipse.zest.core.widgets.GraphNode;
import org.eclipse.zest.core.widgets.IContainer;

/**
 * Base class that can be used for model factories. Offers facilities to style
 * the items that have been created by the factory.
 * 

	private AbstractStructuredGraphViewer viewer;
	private int connectionStyle;
	private int nodeStyle;
	private List /* ConstraintAdapater */constraintAdapters = new ArrayList();

	/**
	 * 

		this.viewer = viewer;
		this.connectionStyle = SWT.NONE;
		this.nodeStyle = SWT.NONE;
		if (viewer instanceof AbstractStructuredGraphViewer) {
			this.constraintAdapters = (viewer).getConstraintAdapters();
		}
	}

	public void styleConnection(GraphConnection conn) {

					return node;
				}
				for (int i = 0; i < childNodes.length; i++) {
					GraphNode childNode = viewer.addGraphModelNode((GraphContainer) node, childNodes[i]);
					styleItem(childNode);
				}
				((GraphContainer) node).applyLayout();
				return node;
			}
		}

		this.nodeStyle = style;
	}

	public List /* ConstraintAdapter */getConstraintAdapters() {
		return this.constraintAdapters;
	}

	/**
	 * @return the nodeStyle
	 */

		clearGraph(model);
		model.setConnectionStyle(getConnectionStyle());
		model.setNodeStyle(getNodeStyle());
		model.setConstraintAdapters(getConstraintAdapters());
	}

	/**




/*******************************************************************************
 * Copyright 2005-2009, CHISEL Group, University of Victoria, Victoria, BC,
 * Canada. 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:
 *     The Chisel Group, University of Victoria
 *     Mateusz Matela <mateusz.matela@gmail.com> - Adapt Zest to changes in layout - https://bugs.eclipse.org/bugs/show_bug.cgi?id=283179
 ******************************************************************************/

package org.eclipse.zest.core.widgets;

import java.util.ArrayList;

import org.eclipse.draw2d.geometry.Point;
import org.eclipse.draw2d.geometry.PrecisionPoint;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.swt.SWT;
import org.eclipse.swt.graphics.Color;
import org.eclipse.swt.graphics.Font;
import org.eclipse.swt.graphics.FontData;
import org.eclipse.swt.graphics.Image;
import org.eclipse.swt.widgets.Display;
import org.eclipse.zest.core.widgets.ZestStyles;
import org.eclipse.zest.core.widgets.internal.GraphLabel;
import org.eclipse.zest.layouts.LayoutEntity;
import org.eclipse.zest.layouts.constraints.LayoutConstraint;

/**
 * Simple node class which has the following properties: color, size, location,
 * and a label. It also has a list of connections and anchors.
 * 

public class GraphNode extends GraphItem {
	public static final int HIGHLIGHT_NONE = 0;
	public static final int HIGHLIGHT_ON = 1;
	// @tag ADJACENT : Removed highlight adjacent
	//public static final int HIGHLIGHT_ADJACENT = 2;

	private int nodeStyle;


	private Color foreColor;
	private Color backColor;
	private Color highlightColor;
	// @tag ADJACENT : Removed highlight adjacent
	//private Color highlightAdjacentColor;
	private Color borderColor;
	private Color borderHighlightColor;
	private int borderWidth;

	private Font font;
	private boolean cacheLabel;
	private boolean visible = true;
	private LayoutEntity layoutEntity;

	protected Graph graph;
	protected NodeContainerAdapter parent;

	/** The internal node. */
	protected Object internalNode;

	private boolean isDisposed = false;
	private boolean hasCustomTooltip;

	public GraphNode(Graph graphModel, int style) {
		this(graphModel, style, null);
	}

	public GraphNode(Graph graphModel, int style, Object data) {
		this(graphModel, style, "" /* text */, null /* image */, data);
	}

	public GraphNode(Graph graphModel, int style, String text) {
		this(graphModel, style, text, null);
	}

	public GraphNode(Graph graphModel, int style, String text, Object data) {
		this(graphModel, style, text, null /* image */, data);
	}

	public GraphNode(Graph graphModel, int style, String text, Image image) {
		this(graphModel, style, text, image, null);
	}

	public GraphNode(Graph graphModel, int style, String text, Image image, Object data) {
		this(NodeContainerAdapter.get(graphModel), style, text, image, data);
	}

	public GraphNode(GraphContainer graphModel, int style) {
		this(graphModel, style, null);
	}

	public GraphNode(GraphContainer graphModel, int style, Object data) {
		this(graphModel, style, "" /* text */, null /* image */, data);
	}

	public GraphNode(GraphContainer graphModel, int style, String text) {
		this(graphModel, style, text, null);
	}

	public GraphNode(GraphContainer graphModel, int style, String text, Object data) {
		this(graphModel, style, text, null /* image */, data);
	}

	public GraphNode(GraphContainer graphModel, int style, String text, Image image) {
		this(graphModel, style, text, image, null);
	}

	public GraphNode(GraphContainer graphModel, int style, String text, Image image, Object data) {
		this(NodeContainerAdapter.get(graphModel), style, text, image, data);
	}

	private GraphNode(NodeContainerAdapter graphModel, int style, String text, Image image, Object data) {
		super(graphModel.getGraph(), style, data);
		initModel(graphModel, text, image);
		if (nodeFigure == null) {
			initFigure();
		}

		this.parent.addNode(this);
		// I don't want to expose addNode so I can't put it in the
		// IContainer interface.  
		if (this.parent.getItemType() == GRAPH) {
			((Graph) this.parent).addNode(this);
		} else if (this.parent.getItemType() == CONTAINER) {
			((GraphContainer) this.parent).addNode(this);
		}
		this.parent.getGraph().registerItem(this);
	}



	static int count = 0;

	protected void initModel(NodeContainerAdapter graphModel, String text, Image image) {
		this.nodeStyle |= graphModel.getGraph().getNodeStyle();
		this.parent = graphModel;
		this.sourceConnections = new ArrayList();
		this.targetConnections = new ArrayList();
		this.foreColor = graphModel.getGraph().DARK_BLUE;
		this.backColor = graphModel.getGraph().LIGHT_BLUE;
		this.highlightColor = graphModel.getGraph().HIGHLIGHT_COLOR;
		// @tag ADJACENT : Removed highlight adjacent
		//this.highlightAdjacentColor = ColorConstants.orange;
		this.nodeStyle = SWT.NONE;
		this.borderColor = ColorConstants.lightGray;
		this.borderHighlightColor = ColorConstants.blue;
		this.borderWidth = 1;
		this.currentLocation = new PrecisionPoint(0, 0);
		this.size = new Dimension(-1, -1);
		this.font = Display.getDefault().getSystemFont();
		this.graph = graphModel.getGraph();
		this.cacheLabel = false;
		this.setText(text);
		this.layoutEntity = new LayoutGraphNode();
		if (image != null) {
			this.setImage(image);
		}

		return "GraphModelNode: " + getText();
	}

	public LayoutEntity getLayoutEntity() {
		return layoutEntity;
	}

	/*
	 * (non-Javadoc)
	 * 

	 * Sets the current location for this node.
	 */
	public void setLocation(double x, double y) {
		if (currentLocation.x != x || currentLocation.y != y) {
			currentLocation.x = (int) x;
			currentLocation.y = (int) y;
			refreshLocation();
		}
	}

	/**

	}

	/**
	 * Get the highlight adjacent colour for this node. This is the colour that
	 * adjacent nodes will get
	 */
	// @tag ADJACENT : Removed highlight adjacent
	/*
	public Color getHighlightAdjacentColor() {
		return highlightAdjacentColor;
	}
	*/

	/**
	 * Set the highlight adjacent colour for this node. This is the colour that
	 * adjacent node will get.
	 */
	// @tag ADJACENT : Removed highlight adjacent
	/*
	public void setHighlightAdjacentColor(Color c) {
		this.highlightAdjacentColor = c;
	}
	*/

	/**
	 * Highlights the node changing the background color and border color. The
	 * source and destination connections are also highlighted, and the adjacent
	 * nodes are highlighted too in a different color.

		if (highlighted == HIGHLIGHT_ON) {
			return;
		}
		parent.highlightNode(this);
		/*
		if (ZestStyles.checkStyle(getNodeStyle(), ZestStyles.NODES_HIGHLIGHT_ADJACENT)) {
			for (Iterator iter = sourceConnections.iterator(); iter.hasNext();) {
				GraphConnection conn = (GraphConnection) iter.next();
				conn.highlight();
				conn.getDestination().highlightAdjacent();
			}
			for (Iterator iter = targetConnections.iterator(); iter.hasNext();) {
				GraphConnection conn = (GraphConnection) iter.next();
				conn.highlight();
				conn.getSource().highlightAdjacent();
			}
		}
		*/
		if (parent.getItemType() == GraphItem.CONTAINER) {
			((GraphContainer) parent).highlightNode(this);
		} else {
			((Graph) parent).highlightNode(this);
		}
		highlighted = HIGHLIGHT_ON;
		updateFigureForModel(getNodeFigure());
	}

	 */
	public void unhighlight() {

		// @tag ADJACENT : Removed highlight adjacent
		//boolean highlightedAdjacently = (highlighted == HIGHLIGHT_ADJACENT);
		if (highlighted == HIGHLIGHT_NONE) {
			return;
		}

		parent.unhighlightNode(this);

			// IF we are highlighted as an adjacent node, we don't need to deal
			// with our connections.
			if (ZestStyles.checkStyle(getNodeStyle(), ZestStyles.NODES_HIGHLIGHT_ADJACENT)) {
				// unhighlight the adjacent edges
				for (Iterator iter = sourceConnections.iterator(); iter.hasNext();) {
					GraphConnection conn = (GraphConnection) iter.next();
					conn.unhighlight();
					if (conn.getDestination() != this) {
						conn.getDestination().unhighlight();
					}
				}
				for (Iterator iter = targetConnections.iterator(); iter.hasNext();) {
					GraphConnection conn = (GraphConnection) iter.next();
					conn.unhighlight();
					if (conn.getSource() != this) {
						conn.getSource().unhighlight();
					}
				}
			}
		}
		*/
		if (parent.getItemType() == GraphItem.CONTAINER) {
			((GraphContainer) parent).unhighlightNode(this);
		} else {
			((Graph) parent).unhighlightNode(this);
		}
		highlighted = HIGHLIGHT_NONE;
		updateFigureForModel(nodeFigure);


		if (nodeFigure == null || nodeFigure.getParent() == null) {
			return; // node figure has not been created yet
		}
		//nodeFigure.setBounds(bounds);
		nodeFigure.getParent().setConstraint(nodeFigure, bounds);
	}

	/**
	 * Highlights this node using the adjacent highlight color. This only does
	 * something if highlighAdjacentNodes is set to true and if the node isn't
	 * already highlighted.
	 * 
	 * @see #setHighlightAdjacentNodes(boolean)
	 */
	// @tag ADJACENT : removed highlight adjacent
	/*
	public void highlightAdjacent() {
		if (highlighted > 0) {
			return;
		}
		highlighted = HIGHLIGHT_ADJACENT;
		updateFigureForModel(nodeFigure);
		if (parent.getItemType() == GraphItem.CONTAINER) {
			((GraphContainer) parent).highlightNode(this);
		} else {
			((Graph) parent).highlightNode(this);
		}
	}
	*/

	/**
	 * Returns if the nodes adjacent to this node will be highlighted when this
	 * node is selected.
	 * 
	 * @return GraphModelNode
	 */
	// @tag ADJACENT : Removed highlight adjacent
	/*
	public boolean isHighlightAdjacentNodes() {
		return ZestStyles.checkStyle(nodeStyle, ZestStyles.NODES_HIGHLIGHT_ADJACENT);
	}
	*/

	/**
	 * Sets if the adjacent nodes to this one should be highlighted when this
	 * node is selected.
	 * 
	 * @param highlightAdjacentNodes
	 *            The highlightAdjacentNodes to set.
	 */
	// @tag ADJACENT : Removed highlight adjacent
	/*
	public void setHighlightAdjacentNodes(boolean highlightAdjacentNodes) {
		if (!highlightAdjacentNodes) {
			this.nodeStyle |= ZestStyles.NODES_HIGHLIGHT_ADJACENT;
			this.nodeStyle ^= ZestStyles.NODES_HIGHLIGHT_ADJACENT;
			return;
		}
		this.nodeStyle |= ZestStyles.NODES_HIGHLIGHT_ADJACENT;
	}
	*/

	public Color getBorderColor() {
		return borderColor;
	}

		this.cacheLabel = cacheLabel;
	}

	IFigure getNodeFigure() {
		return this.nodeFigure;
	}

	public void setVisible(boolean visible) {
		// graph.addRemoveFigure(this, visible);
		this.visible = visible;
		this.getFigure().setVisible(visible);
		for (Iterator iterator2 = sourceConnections.iterator(); iterator2.hasNext();) {
		List tConnections = (this).getTargetConnections();
		for (Iterator iterator2 = sConnections.iterator(); iterator2.hasNext();) {
			GraphConnection connection = (GraphConnection) iterator2.next();
			connection.setVisible(visible);
		}

		for (Iterator iterator2 = targetConnections.iterator(); iterator2.hasNext();) {
			GraphConnection connection = (GraphConnection) iterator2.next();
			connection.setVisible(visible);
		}
	}

	public boolean isVisible() {
		return visible;
	}

	public int getStyle() {
		return super.getStyle() | this.getNodeStyle();
	}

	 **************************************************************************/

	private IFigure fishEyeFigure = null;
	private Font fishEyeFont = null;
	private boolean isFisheyeEnabled;

	protected IFigure fishEye(boolean enable, boolean animate) {

			Dimension newSize = fishEyeFigure.getPreferredSize();
			Rectangle currentSize = rectangle.getCopy();
			nodeFigure.translateToAbsolute(currentSize);
			int expandedH = Math.max((newSize.height - currentSize.height) / 2 + 1, 0);
			int expandedW = Math.max((newSize.width - currentSize.width) / 2 + 1, 0);
			Dimension expandAmount = new Dimension(expandedW, expandedH);
			nodeFigure.translateToAbsolute(rectangle);
			rectangle.expand(new Insets(expandAmount.height, expandAmount.width, expandAmount.height, expandAmount.width));

				return null;
			}

			FontData fontData = Display.getCurrent().getSystemFont().getFontData()[0];
			fontData.height = 12;
			fishEyeFont = new Font(Display.getCurrent(), fontData);
			fishEyeFigure.setFont(fishEyeFont);

			//Add the fisheye
			this.getGraphModel().fishEye(nodeFigure, fishEyeFigure, rectangle, true);
			if (fishEyeFigure != null) {

		} else {
			// Remove the fisheye and dispose the font
			this.getGraphModel().removeFishEye(fishEyeFigure, nodeFigure, animate);
			if (fishEyeFont != null) {
				this.fishEyeFont.dispose();
				this.fishEyeFont = null;
			}
			isFisheyeEnabled = false;
			return null;
		}
	}

	NodeContainerAdapter getParent() {
		return parent;
	}


		return highlighted > 0;
	}

	void invokeLayoutListeners(LayoutConstraint constraint) {
		graph.invokeConstraintAdapters(this, constraint);
	}

	protected void updateFigureForModel(IFigure currentFigure) {
		if (currentFigure == null) {
			return;

		boolean cacheLabel = this.cacheLabel();
		GraphLabel label = new GraphLabel(node.getText(), node.getImage(), cacheLabel);

		if (!checkStyle(ZestStyles.NODES_HIDE_TEXT)) {
			label.setText(this.getText());
		}
		label.setIcon(getImage());

		// @tag TODO: Add border and foreground colours to highlight
		// (this.borderColor)
		if (highlighted == HIGHLIGHT_ON) {
			label.setForegroundColor(getForegroundColor());
			label.setBackgroundColor(getHighlightColor());
			label.setBorderColor(getBorderHighlightColor());
		} else {
			label.setForegroundColor(getForegroundColor());
			label.setBackgroundColor(getBackgroundColor());
			label.setBorderColor(getBorderColor());
		}

		label.setBorderWidth(getBorderWidth());
		label.setFont(getFont());
		return label;
	}

		return label;
		return visible;
	}

	void addSourceConnection(GraphConnection connection) {

		return NODE;
	}

	class LayoutGraphNode implements LayoutEntity {
		Object layoutInformation = null;

		public double getHeightInLayout() {
			return getSize().height;
		}

		public Object getLayoutInformation() {
			return layoutInformation;
		}

		public String toString() {
			return getText();
		}

		public double getWidthInLayout() {
			return getSize().width;
		}

		public double getXInLayout() {
			return getLocation().x;
		}

		public double getYInLayout() {
			return getLocation().y;
		}

		public void populateLayoutConstraint(LayoutConstraint constraint) {
			invokeLayoutListeners(constraint);
		}

		public void setLayoutInformation(Object internalEntity) {
			this.layoutInformation = internalEntity;

		}

		public void setLocationInLayout(double x, double y) {
			setLocation(x, y);
		}

		public void setSizeInLayout(double width, double height) {
			setSize(width, height);
		}

		/**
		 * Compares two nodes.
		 */
		public int compareTo(Object otherNode) {
			int rv = 0;
			if (otherNode instanceof GraphNode) {
				GraphNode node = (GraphNode) otherNode;
				if (getText() != null) {
					rv = getText().compareTo(node.getText());
				}
			}
			return rv;
		}

		public Object getGraphData() {
			return GraphNode.this;
		}

		public void setGraphData(Object o) {
			// TODO Auto-generated method stub

		}

	}

	IFigure getFigure() {
		if (this.nodeFigure == null) {
			initFigure();

		return this.getNodeFigure();
	}

	private InternalNodeLayout layout;

	InternalNodeLayout getLayout() {
		if (layout == null) {
			layout = new InternalNodeLayout(this);
		}
		return layout;
	}

	void applyLayoutChanges() {
		if (layout != null)
			layout.applyLayout();
	}
}

Lines 1-18 Link Here

(-)src/org/eclipse/zest/core/widgets/Graph.java (-328 / +117 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright 2005, CHISEL Group, University of Victoria, Victoria, BC, Canada.	2	* Copyright 2005-2009, CHISEL Group, University of Victoria, Victoria, BC,
3	* All rights reserved. This program and the accompanying materials are made	3	* Canada. All rights reserved. This program and the accompanying materials are
4	* available under the terms of the Eclipse Public License v1.0 which	4	* made available under the terms of the Eclipse Public License v1.0 which
5	* accompanies this distribution, and is available at	5	* accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*	7	*
8	* Contributors: The Chisel Group, University of Victoria	8	* Contributors:
		9	* The Chisel Group, University of Victoria
		10	* Mateusz Matela <mateusz.matela@gmail.com> - ongoing development
9	******************************************************************************/	11	******************************************************************************/
		12
10	package org.eclipse.zest.core.widgets;	13	package org.eclipse.zest.core.widgets;
11		14
12	import java.util.ArrayList;	15	import java.util.ArrayList;
13	import java.util.HashMap;	16	import java.util.HashMap;
14	import java.util.Iterator;	17	import java.util.Iterator;
15	import java.util.LinkedList;
16	import java.util.List;	18	import java.util.List;
17		19
18	import org.eclipse.draw2d.Animation;	20	import org.eclipse.draw2d.Animation;
Lines 34-39 Link Here
34	import org.eclipse.draw2d.geometry.Point;	36	import org.eclipse.draw2d.geometry.Point;
35	import org.eclipse.draw2d.geometry.Rectangle;	37	import org.eclipse.draw2d.geometry.Rectangle;
36	import org.eclipse.swt.SWT;	38	import org.eclipse.swt.SWT;
		39	import org.eclipse.swt.events.ControlEvent;
		40	import org.eclipse.swt.events.ControlListener;
37	import org.eclipse.swt.events.PaintEvent;	41	import org.eclipse.swt.events.PaintEvent;
38	import org.eclipse.swt.events.PaintListener;	42	import org.eclipse.swt.events.PaintListener;
39	import org.eclipse.swt.events.SelectionAdapter;	43	import org.eclipse.swt.events.SelectionAdapter;
Lines 41-69 Link Here
41	import org.eclipse.swt.events.SelectionListener;	45	import org.eclipse.swt.events.SelectionListener;
42	import org.eclipse.swt.graphics.Color;	46	import org.eclipse.swt.graphics.Color;
43	import org.eclipse.swt.widgets.Composite;	47	import org.eclipse.swt.widgets.Composite;
44	import org.eclipse.swt.widgets.Control;
45	import org.eclipse.swt.widgets.Display;	48	import org.eclipse.swt.widgets.Display;
46	import org.eclipse.swt.widgets.Event;	49	import org.eclipse.swt.widgets.Event;
47	import org.eclipse.swt.widgets.Item;	50	import org.eclipse.swt.widgets.Item;
48	import org.eclipse.zest.core.widgets.internal.ContainerFigure;	51	import org.eclipse.zest.core.widgets.internal.ContainerFigure;
49	import org.eclipse.zest.core.widgets.internal.RevealListener;
50	import org.eclipse.zest.core.widgets.internal.ZestRootLayer;	52	import org.eclipse.zest.core.widgets.internal.ZestRootLayer;
51	import org.eclipse.zest.layouts.InvalidLayoutConfiguration;
52	import org.eclipse.zest.layouts.LayoutAlgorithm;	53	import org.eclipse.zest.layouts.LayoutAlgorithm;
53	import org.eclipse.zest.layouts.LayoutEntity;
54	import org.eclipse.zest.layouts.LayoutRelationship;
55	import org.eclipse.zest.layouts.LayoutStyles;
56	import org.eclipse.zest.layouts.algorithms.TreeLayoutAlgorithm;
57	import org.eclipse.zest.layouts.constraints.LayoutConstraint;
58		54
59	/*	55	public class Graph extends FigureCanvas {
60	* Holds the nodes and connections for the graph.
61	*
62	* @author Chris Callendar
63	*
64	* @author Ian Bull
65	*/
66	public class Graph extends FigureCanvas implements IContainer {
67		56
68	// CLASS CONSTANTS	57	// CLASS CONSTANTS
69	public static final int ANIMATION_TIME = 500;	58	public static final int ANIMATION_TIME = 500;
Lines 94-107 Link Here
94	/** This maps all visible nodes to their model element. */	83	/** This maps all visible nodes to their model element. */
95	private HashMap figure2ItemMap = null;	84	private HashMap figure2ItemMap = null;
96		85
97	/** Maps user nodes to internal nodes */
98	private int connectionStyle;	86	private int connectionStyle;
99	private int nodeStyle;	87	private int nodeStyle;
100	private List constraintAdapters;
101	private List revealListeners = null;
102
103	private ScalableFreeformLayeredPane fishEyeLayer = null;	88	private ScalableFreeformLayeredPane fishEyeLayer = null;
104	LayoutAlgorithm layoutAlgorithm = null;	89	private LayoutAlgorithm layoutAlgorithm = null;
		90	private InternalLayoutContext layoutContext = null;
		91	private volatile boolean isLayoutScheduled;
105	private Dimension preferredSize = null;	92	private Dimension preferredSize = null;
106	int style = 0;	93	int style = 0;
107		94
Lines 120-131 Link Here
120	this.style = style;	107	this.style = style;
121	this.setBackground(ColorConstants.white);	108	this.setBackground(ColorConstants.white);
122		109
123	LIGHT_BLUE = new Color(Display.getDefault(), 216, 228, 248);
124	LIGHT_BLUE_CYAN = new Color(Display.getDefault(), 213, 243, 255);
125	GREY_BLUE = new Color(Display.getDefault(), 139, 150, 171);
126	DARK_BLUE = new Color(Display.getDefault(), 1, 70, 122);
127	LIGHT_YELLOW = new Color(Display.getDefault(), 255, 255, 206);
128
129	this.setViewport(new FreeformViewport());	110	this.setViewport(new FreeformViewport());
130		111
131	this.getVerticalBar().addSelectionListener(new SelectionAdapter() {	112	this.getVerticalBar().addSelectionListener(new SelectionAdapter() {
Lines 164-170 Link Here
164	});	145	});
165		146
166	this.setContents(createLayers());	147	this.setContents(createLayers());
167	DragSupport dragSupport = new DragSupport(this);	148	DragSupport dragSupport = new DragSupport();
168	this.getLightweightSystem().getRootFigure().addMouseListener(dragSupport);	149	this.getLightweightSystem().getRootFigure().addMouseListener(dragSupport);
169	this.getLightweightSystem().getRootFigure().addMouseMotionListener(dragSupport);	150	this.getLightweightSystem().getRootFigure().addMouseMotionListener(dragSupport);
170		151
Lines 173-208 Link Here
173	this.connectionStyle = ZestStyles.NONE;	154	this.connectionStyle = ZestStyles.NONE;
174	this.nodeStyle = ZestStyles.NONE;	155	this.nodeStyle = ZestStyles.NONE;
175	this.connections = new ArrayList();	156	this.connections = new ArrayList();
176	this.constraintAdapters = new ArrayList();
177	this.selectedItems = new ArrayList();	157	this.selectedItems = new ArrayList();
178	this.selectionListeners = new ArrayList();	158	this.selectionListeners = new ArrayList();
179	this.figure2ItemMap = new HashMap();	159	this.figure2ItemMap = new HashMap();
180		160
181	revealListeners = new ArrayList(1);
182	this.addPaintListener(new PaintListener() {	161	this.addPaintListener(new PaintListener() {
183	public void paintControl(PaintEvent e) {	162	public void paintControl(PaintEvent e) {
184	if (!revealListeners.isEmpty()) {	163	if (isLayoutScheduled) {
185	// Go through the reveal list and let everyone know that the	164	applyLayoutInternal();
186	// view is now available. Remove the listeners so they are	165	isLayoutScheduled = false;
187	// only
188	// called once!
189	Iterator iterator = revealListeners.iterator();
190	while (iterator.hasNext()) {
191	RevealListener reveallisetner = (RevealListener) iterator.next();
192	reveallisetner.revealed(Graph.this);
193	iterator.remove();
194	}
195	}	166	}
196	/*
197	Iterator iterator = getNodes().iterator();
198	while (iterator.hasNext()) {
199	GraphNode node = (GraphNode) iterator.next();
200	node.paint();
201	}
202	*/
203	}	167	}
204	});	168	});
205		169
		170	this.addControlListener(new ControlListener() {
		171
		172	public void controlResized(ControlEvent e) {
		173	if (preferredSize.width == -1 \|\| preferredSize.height == -1) {
		174	getLayoutContext().fireBoundsChangedEvent();
		175	}
		176	}
		177
		178	public void controlMoved(ControlEvent e) {
		179	// do nothing
		180	}
		181	});
206	}	182	}
207		183
208	/**	184	/**
Lines 235-257 Link Here
235	}	211	}
236		212
237	/**	213	/**
238	* Adds a new constraint adapter to the list of constraint adapters
239	* @param constraintAdapter
240	*/
241	public void addConstraintAdapter(ConstraintAdapter constraintAdapter) {
242	this.constraintAdapters.add(constraintAdapter);
243	}
244
245	/**
246	* Sets the constraint adapters on this model
247	*
248	* @param constraintAdapters
249	*/
250	public void setConstraintAdapters(List /* ConstraintAdapters */constraintAdapters) {
251	this.constraintAdapters = constraintAdapters;
252	}
253
254	/**
255	* Gets the root layer for this graph	214	* Gets the root layer for this graph
256	*	215	*
257	* @return	216	* @return
Lines 326-331 Link Here
326	}	285	}
327	}	286	}
328	}	287	}
		288	// TODO shouldn't this method fire a selection event?
329	}	289	}
330		290
331	public void selectAll() {	291	public void selectAll() {
Lines 334-339 Link Here
334	selectedItems.add(nodes.get(i));	294	selectedItems.add(nodes.get(i));
335	((GraphNode) nodes.get(i)).highlight();	295	((GraphNode) nodes.get(i)).highlight();
336	}	296	}
		297	// TODO shouldn't this method fire a selection event?
337	}	298	}
338		299
339	/**	300	/**
Lines 354-368 Link Here
354	return "GraphModel {" + nodes.size() + " nodes, " + connections.size() + " connections}";	315	return "GraphModel {" + nodes.size() + " nodes, " + connections.size() + " connections}";
355	}	316	}
356		317
357	/*
358	* (non-Javadoc)
359	*
360	* @see org.eclipse.mylar.zest.core.internal.graphmodel.IGraphItem#getGraphModel()
361	*/
362	public Graph getGraphModel() {
363	return this;
364	}
365
366	/**	318	/**
367	* Dispose of the nodes and edges when the graph is disposed.	319	* Dispose of the nodes and edges when the graph is disposed.
368	*/	320	*/
Lines 389-407 Link Here
389	}	341	}
390		342
391	/**	343	/**
392	* Runs the layout on this graph. It uses the reveal listner to run the	344	* Runs the layout on this graph. If the view is not visible layout will be
393	* layout only if the view is visible. Otherwise it will be deferred until	345	* deferred until after the view is available.
394	* after the view is available.
395	*/	346	*/
396	public void applyLayout() {	347	public void applyLayout() {
397	this.addRevealListener(new RevealListener() {	348	scheduleLayoutOnReveal();
398	public void revealed(Control c) {	349	}
399	Display.getDefault().asyncExec(new Runnable() {
400		350
401	public void run() {	351	private void applyLayoutInternal() {
402	applyLayoutInternal();	352	if (layoutAlgorithm == null) {
403	}	353	return;
404	});	354	}
		355	Display.getDefault().asyncExec(new Runnable() {
		356	public void run() {
		357	Animation.markBegin();
		358	layoutAlgorithm.applyLayout();
		359	layoutContext.flushChanges(false);
		360	Animation.run(ANIMATION_TIME);
		361	getLightweightSystem().getUpdateManager().performUpdate();
405	}	362	}
406	});	363	});
407	}	364	}
Lines 415-427 Link Here
415	*/	372	*/
416	public void setPreferredSize(int width, int height) {	373	public void setPreferredSize(int width, int height) {
417	this.preferredSize = new Dimension(width, height);	374	this.preferredSize = new Dimension(width, height);
		375	getLayoutContext().fireBoundsChangedEvent();
		376	}
		377
		378	/**
		379	*
		380	* @return the preferred size of the layout area.
		381	*/
		382	public Dimension getPreferredSize() {
		383	if (preferredSize.width < 0 \|\| preferredSize.height < 0) {
		384	org.eclipse.swt.graphics.Point size = getSize();
		385	return new Dimension(size.x, size.y);
		386	}
		387	return preferredSize;
		388	}
		389
		390	InternalLayoutContext getLayoutContext() {
		391	if (layoutContext == null) {
		392	layoutContext = new InternalLayoutContext(this);
		393	}
		394	return layoutContext;
418	}	395	}
419		396
420	/**	397	/**
421	* @param algorithm	398	* @param algorithm
422	*/	399	*/
423	public void setLayoutAlgorithm(LayoutAlgorithm algorithm, boolean applyLayout) {	400	public void setLayoutAlgorithm(LayoutAlgorithm algorithm, boolean applyLayout) {
		401	if (this.layoutAlgorithm != null) {
		402	this.layoutAlgorithm.setLayoutContext(null);
		403	}
424	this.layoutAlgorithm = algorithm;	404	this.layoutAlgorithm = algorithm;
		405	this.layoutAlgorithm.setLayoutContext(getLayoutContext());
425	if (applyLayout) {	406	if (applyLayout) {
426	applyLayout();	407	applyLayout();
427	}	408	}
Lines 432-437 Link Here
432	}	413	}
433		414
434	/**	415	/**
		416	* Adds a filter used for hiding elements from layout algorithm.
		417	*
		418	* NOTE: If a node or subgraph if filtered out, all connections adjacent to
		419	* it should also be filtered out. Otherwise layout algorithm may behave in
		420	* an unexpected way.
		421	*
		422	* @param filter
		423	* filter to add
		424	*/
		425	public void addLayoutFilter(LayoutFilter filter) {
		426	getLayoutContext().addFilter(filter);
		427	}
		428
		429	/**
		430	* Removes given layout filter. If it had not been added to this graph, this
		431	* method does nothing.
		432	*
		433	* @param filter
		434	* filter to remove
		435	*/
		436	public void removeLayoutFilter(LayoutFilter filter) {
		437	getLayoutContext().removeFilter(filter);
		438	}
		439
		440	/**
435	* Finds a figure at the location X, Y in the graph	441	* Finds a figure at the location X, Y in the graph
436	*	442	*
437	* This point should be translated to relative before calling findFigureAt	443	* This point should be translated to relative before calling findFigureAt
Lines 472-493 Link Here
472		478
473	}	479	}
474		480
475	// /////////////////////////////////////////////////////////////////////////////////	481	private class DragSupport implements MouseMotionListener, org.eclipse.draw2d.MouseListener {
476	// PRIVATE METHODS. These are NON API	482
477	// /////////////////////////////////////////////////////////////////////////////////
478	class DragSupport implements MouseMotionListener, org.eclipse.draw2d.MouseListener {
479	/**
480	*
481	*/
482	Graph graph = null;
483	Point lastLocation = null;	483	Point lastLocation = null;
484	GraphItem fisheyedItem = null;	484	GraphItem fisheyedItem = null;
485	boolean isDragging = false;	485	boolean isDragging = false;
486		486
487	DragSupport(Graph graph) {
488	this.graph = graph;
489	}
490
491	public void mouseDragged(org.eclipse.draw2d.MouseEvent me) {	487	public void mouseDragged(org.eclipse.draw2d.MouseEvent me) {
492	if (!isDragging) {	488	if (!isDragging) {
493	return;	489	return;
Lines 514-525 Link Here
514	node.setLocation(node.getLocation().x + delta.x, node.getLocation().y + delta.y);	510	node.setLocation(node.getLocation().x + delta.x, node.getLocation().y + delta.y);
515		511
516	}	512	}
517	/*
518	else if (item.getItemType() == GraphItem.CONTAINER) {
519	GraphContainer container = (GraphContainer) item;
520	container.setLocation(container.getLocation().x + delta.x, container.getLocation().y + delta.y);
521	}
522	*/
523	} else {	513	} else {
524	// There is no movement for connection	514	// There is no movement for connection
525	}	515	}
Lines 537-548 Link Here
537	Point point = new Point(fisheyedFigure.getBounds().x + delta.x, fisheyedFigure.getBounds().y + delta.y);	527	Point point = new Point(fisheyedFigure.getBounds().x + delta.x, fisheyedFigure.getBounds().y + delta.y);
538	fishEyeLayer.setConstraint(fisheyedFigure, new Rectangle(point, fisheyedFigure.getSize()));	528	fishEyeLayer.setConstraint(fisheyedFigure, new Rectangle(point, fisheyedFigure.getSize()));
539	fishEyeLayer.getUpdateManager().performUpdate();	529	fishEyeLayer.getUpdateManager().performUpdate();
540	//fisheyedFigure.setBounds(new Rectangle(point2, fisheyedFigure.getSize()));
541	//fisheyedFigure.setLocation(new Point(fisheyedFigure.getBounds().x + delta.x, fisheyedFigure.getBounds().y + delta.y));
542	}	530	}
543	}	531	}
544	lastLocation = tempPoint;	532	lastLocation = tempPoint;
545	//oldLocation = mousePoint;
546	}	533	}
547		534
548	public void mouseEntered(org.eclipse.draw2d.MouseEvent me) {	535	public void mouseEntered(org.eclipse.draw2d.MouseEvent me) {
Lines 638-644 Link Here
638	}	625	}
639	// If the figure under the mouse is the canvas, and CTRL is not being held down, then select	626	// If the figure under the mouse is the canvas, and CTRL is not being held down, then select
640	// nothing	627	// nothing
641	if (figureUnderMouse == null \|\| figureUnderMouse == graph) {	628	if (figureUnderMouse == null \|\| figureUnderMouse == Graph.this) {
642	if (me.getState() != org.eclipse.draw2d.MouseEvent.CONTROL) {	629	if (me.getState() != org.eclipse.draw2d.MouseEvent.CONTROL) {
643	clearSelection();	630	clearSelection();
644	if (hasSelection) {	631	if (hasSelection) {
Lines 763-792 Link Here
763	}	750	}
764		751
765	/**	752	/**
766	* Moves the node onto the node feedback layer
767	*
768	* @param node
769	*/
770	void highlightNode(GraphContainer node) {
771	IFigure figure = node.getNodeFigure();
772	if (figure != null && !node.isHighlighted()) {
773	zestRootLayer.highlightNode(figure);
774	}
775	}
776
777	/**
778	* Moves the node off the node feedback layer
779	*
780	* @param node
781	*/
782	void unhighlightNode(GraphContainer node) {
783	IFigure figure = node.getNodeFigure();
784	if (figure != null && node.isHighlighted()) {
785	zestRootLayer.unHighlightNode(figure);
786	}
787	}
788
789	/**
790	* Moves the node off the node feedback layer	753	* Moves the node off the node feedback layer
791	*	754	*
792	* @param node	755	* @param node
Lines 810-865 Link Here
810	return connsArray;	773	return connsArray;
811	}	774	}
812		775
813	LayoutRelationship[] getConnectionsToLayout(List nodesToLayout) {
814	// @tag zest.bug.156528-Filters.follows : make sure not to layout
815	// filtered connections, if the style says so.
816	LayoutRelationship[] entities;
817	if (ZestStyles.checkStyle(style, ZestStyles.IGNORE_INVISIBLE_LAYOUT)) {
818	LinkedList connectionList = new LinkedList();
819	for (Iterator i = this.getConnections().iterator(); i.hasNext();) {
820	GraphConnection next = (GraphConnection) i.next();
821	if (next.isVisible() && nodesToLayout.contains(next.getSource()) && nodesToLayout.contains(next.getDestination())) {
822	connectionList.add(next.getLayoutRelationship());
823	}
824	}
825	entities = (LayoutRelationship[]) connectionList.toArray(new LayoutRelationship[] {});
826	} else {
827	LinkedList nodeList = new LinkedList();
828	for (Iterator i = this.getConnections().iterator(); i.hasNext();) {
829	GraphConnection next = (GraphConnection) i.next();
830	if (nodesToLayout.contains(next.getSource()) && nodesToLayout.contains(next.getDestination())) {
831	nodeList.add(next.getLayoutRelationship());
832	}
833	}
834	entities = (LayoutRelationship[]) nodeList.toArray(new LayoutRelationship[] {});
835	}
836	return entities;
837	}
838
839	LayoutEntity[] getNodesToLayout(List nodes) {
840	// @tag zest.bug.156528-Filters.follows : make sure not to layout
841	// filtered nodes, if the style says so.
842	LayoutEntity[] entities;
843	if (ZestStyles.checkStyle(style, ZestStyles.IGNORE_INVISIBLE_LAYOUT)) {
844	LinkedList nodeList = new LinkedList();
845	for (Iterator i = nodes.iterator(); i.hasNext();) {
846	GraphNode next = (GraphNode) i.next();
847	if (next.isVisible()) {
848	nodeList.add(next.getLayoutEntity());
849	}
850	}
851	entities = (LayoutEntity[]) nodeList.toArray(new LayoutEntity[] {});
852	} else {
853	LinkedList nodeList = new LinkedList();
854	for (Iterator i = nodes.iterator(); i.hasNext();) {
855	GraphNode next = (GraphNode) i.next();
856	nodeList.add(next.getLayoutEntity());
857	}
858	entities = (LayoutEntity[]) nodeList.toArray(new LayoutEntity[] {});
859	}
860	return entities;
861	}
862
863	void removeConnection(GraphConnection connection) {	776	void removeConnection(GraphConnection connection) {
864	IFigure figure = connection.getConnectionFigure();	777	IFigure figure = connection.getConnectionFigure();
865	PolylineConnection sourceContainerConnectionFigure = connection.getSourceContainerConnectionFigure();	778	PolylineConnection sourceContainerConnectionFigure = connection.getSourceContainerConnectionFigure();
Lines 873-878 Link Here
873	if (targetContainerConnectionFigure != null) {	786	if (targetContainerConnectionFigure != null) {
874	figure2ItemMap.remove(targetContainerConnectionFigure);	787	figure2ItemMap.remove(targetContainerConnectionFigure);
875	}	788	}
		789	getLayoutContext().fireConnectionRemovedEvent(connection.getLayout());
876	}	790	}
877		791
878	void removeNode(GraphNode node) {	792	void removeNode(GraphNode node) {
Lines 886-891 Link Here
886	}	800	}
887	this.getNodes().remove(node);	801	this.getNodes().remove(node);
888	figure2ItemMap.remove(figure);	802	figure2ItemMap.remove(figure);
		803	getLayoutContext().fireNodeRemovedEvent(node.getLayout());
889	}	804	}
890		805
891	void addConnection(GraphConnection connection, boolean addToEdgeLayer) {	806	void addConnection(GraphConnection connection, boolean addToEdgeLayer) {
Lines 893-936 Link Here
893	if (addToEdgeLayer) {	808	if (addToEdgeLayer) {
894	zestRootLayer.addConnection(connection.getFigure());	809	zestRootLayer.addConnection(connection.getFigure());
895	}	810	}
		811	getLayoutContext().fireConnectionAddedEvent(connection.getLayout());
896	}	812	}
897		813
898	/*
899	public void redraw() {
900
901	Iterator iterator = this.getConnections().iterator();
902	while (iterator.hasNext()) {
903	GraphConnection connection = (GraphConnection) iterator.next();
904	IFigure figure = connection.getFigure();
905	if (!zestRootLayer.getChildren().contains(figure)) {
906	if (true \|\| false \|\| false) {
907	zestRootLayer.addConnection(connection.getFigure());
908	}
909	}
910	}
911	iterator = this.getNodes().iterator();
912	while (iterator.hasNext()) {
913	GraphNode graphNode = (GraphNode) iterator.next();
914	IFigure figure = graphNode.getFigure();
915	if (!zestRootLayer.getChildren().contains(figure)) {
916	zestRootLayer.addNode(graphNode.getFigure());
917	}
918	}
919
920	super.redraw();
921
922	}
923	*/
924
925	void addNode(GraphNode node) {	814	void addNode(GraphNode node) {
926	this.getNodes().add(node);	815	this.getNodes().add(node);
927	zestRootLayer.addNode(node.getFigure());	816	zestRootLayer.addNode(node.getFigure());
		817	getLayoutContext().fireNodeAddedEvent(node.getLayout());
928	}	818	}
929		819
930	void addNode(GraphContainer graphContainer) {	820	void addFigure(IFigure figure) {
931	this.getNodes().add(graphContainer);	821	rootlayer.add(figure);
932	zestRootLayer.addNode(graphContainer.getFigure());
933
934	}	822	}
935		823
936	void registerItem(GraphItem item) {	824	void registerItem(GraphItem item) {
Lines 954-1071 Link Here
954	}	842	}
955	}	843	}
956		844
957	/*
958
959
960	/**
961	* Changes the figure for a particular node
962	*/
963	void changeNodeFigure(IFigure oldValue, IFigure newFigure, GraphNode graphItem) {
964	if (zestRootLayer.getChildren().contains(oldValue)) {
965	zestRootLayer.remove(oldValue);
966	figure2ItemMap.remove(oldValue);
967	}
968	figure2ItemMap.put(newFigure, graphItem);
969	zestRootLayer.add(newFigure);
970	}
971
972	/**	845	/**
973	* Invoke all the constraint adapaters for this constraints	846	* Schedules a layout to be performed after the view is revealed (or
974	*	847	* immediately, if the view is already revealed).
975	* @param object
976	* @param constraint
977	*/
978	void invokeConstraintAdapters(Object object, LayoutConstraint constraint) {
979	if (constraintAdapters == null) {
980	return;
981	}
982	Iterator iterator = this.constraintAdapters.iterator();
983	while (iterator.hasNext()) {
984	ConstraintAdapter constraintAdapter = (ConstraintAdapter) iterator.next();
985	constraintAdapter.populateConstraint(object, constraint);
986	}
987	}
988
989	private void applyLayoutInternal() {
990
991	if ((this.getNodes().size() == 0)) {
992	return;
993	}
994
995	int layoutStyle = 0;
996
997	if ((nodeStyle & ZestStyles.NODES_NO_LAYOUT_RESIZE) > 0) {
998	layoutStyle = LayoutStyles.NO_LAYOUT_NODE_RESIZING;
999	}
1000
1001	if (layoutAlgorithm == null) {
1002	layoutAlgorithm = new TreeLayoutAlgorithm(layoutStyle);
1003	}
1004
1005	layoutAlgorithm.setStyle(layoutAlgorithm.getStyle() \| layoutStyle);
1006
1007	// calculate the size for the layout algorithm
1008	Dimension d = this.getViewport().getSize();
1009	d.width = d.width - 10;
1010	d.height = d.height - 10;
1011
1012	if (this.preferredSize.width >= 0) {
1013	d.width = preferredSize.width;
1014	}
1015	if (this.preferredSize.height >= 0) {
1016	d.height = preferredSize.height;
1017	}
1018
1019	if (d.isEmpty()) {
1020	return;
1021	}
1022	LayoutRelationship[] connectionsToLayout = getConnectionsToLayout(nodes);
1023	LayoutEntity[] nodesToLayout = getNodesToLayout(getNodes());
1024
1025	try {
1026	Animation.markBegin();
1027	layoutAlgorithm.applyLayout(nodesToLayout, connectionsToLayout, 0, 0, d.width, d.height, false, false);
1028	Animation.run(ANIMATION_TIME);
1029	getLightweightSystem().getUpdateManager().performUpdate();
1030
1031	} catch (InvalidLayoutConfiguration e) {
1032	e.printStackTrace();
1033	}
1034
1035	}
1036
1037	interface MyRunnable extends Runnable {
1038	public boolean isVisible();
1039	}
1040
1041	/**
1042	* Adds a reveal listener to the view. Note: A reveal listener will only
1043	* every be called ONCE!!! even if a view comes and goes. There is no remove
1044	* reveal listener. This is used to defer some events until after the view
1045	* is revealed.
1046	*	848	*
1047	* @param revealListener	849	* @param revealListener
1048	*/	850	*/
1049	private void addRevealListener(final RevealListener revealListener) {	851	private void scheduleLayoutOnReveal() {
1050
1051	MyRunnable myRunnable = new MyRunnable() {
1052	boolean isVisible;
1053
1054	public boolean isVisible() {
1055	return this.isVisible;
1056	}
1057		852
		853	final boolean[] isVisibleSync = new boolean[1];
		854	Display.getDefault().syncExec(new Runnable() {
1058	public void run() {	855	public void run() {
1059	isVisible = Graph.this.isVisible();	856	isVisibleSync[0] = isVisible();
1060	}	857	}
		858	});
1061		859
1062	};	860	if (isVisibleSync[0]) {
1063	Display.getDefault().syncExec(myRunnable);	861	applyLayoutInternal();
1064
1065	if (myRunnable.isVisible()) {
1066	revealListener.revealed(this);
1067	} else {	862	} else {
1068	revealListeners.add(revealListener);	863	isLayoutScheduled = true;
1069	}	864	}
1070	}	865	}
1071		866
Lines 1132-1143 Link Here
1132	if (this.fishEyeLayer.getChildren().contains(oldFigure)) {	927	if (this.fishEyeLayer.getChildren().contains(oldFigure)) {
1133	Rectangle bounds = oldFigure.getBounds();	928	Rectangle bounds = oldFigure.getBounds();
1134	newFigure.setBounds(bounds);	929	newFigure.setBounds(bounds);
1135	//this.fishEyeLayer.getChildren().remove(oldFigure);
1136	this.fishEyeLayer.remove(oldFigure);	930	this.fishEyeLayer.remove(oldFigure);
1137	this.fishEyeLayer.add(newFigure);	931	this.fishEyeLayer.add(newFigure);
1138	//this.fishEyeLayer.getChildren().add(newFigure);
1139	//this.fishEyeLayer.invalidate();
1140	//this.fishEyeLayer.repaint();
1141	this.fisheyedFigure = newFigure;	932	this.fisheyedFigure = newFigure;
1142	return true;	933	return true;
1143	}	934	}
Lines 1182-1192 Link Here
1182	this.getRootLayer().getUpdateManager().performUpdate();	973	this.getRootLayer().getUpdateManager().performUpdate();
1183	}	974	}
1184		975
1185	public Graph getGraph() {
1186	// @tag refactor : Is this method really needed
1187	return this.getGraphModel();
1188	}
1189
1190	public int getItemType() {	976	public int getItemType() {
1191	return GraphItem.GRAPH;	977	return GraphItem.GRAPH;
1192	}	978	}
Lines 1195-1198 Link Here
1195	return (GraphItem) figure2ItemMap.get(figure);	981	return (GraphItem) figure2ItemMap.get(figure);
1196	}	982	}
1197		983
		984	public void setExpanded(GraphNode node, boolean expanded) {
		985	layoutContext.setExpanded(node.getLayout(), expanded);
		986	}
1198	}	987	}

Lines 1-12 Link Here

(-)src/org/eclipse/zest/core/widgets/GraphContainer.java (-248 / +307 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright 2005-2007, CHISEL Group, University of Victoria, Victoria, BC,	2	* Copyright 2005-2009, CHISEL Group, University of Victoria, Victoria, BC,
3	* Canada. All rights reserved. This program and the accompanying materials are	3	* Canada. All rights reserved. This program and the accompanying materials are
4	* made available under the terms of the Eclipse Public License v1.0 which	4	* made available under the terms of the Eclipse Public License v1.0 which
5	* accompanies this distribution, and is available at	5	* accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*	7	*
8	* Contributors: The Chisel Group, University of Victoria	8	* Contributors:
		9	* The Chisel Group, University of Victoria
		10	* Mateusz Matela <mateusz.matela@gmail.com> - Adapt Zest to changes in layout - https://bugs.eclipse.org/bugs/show_bug.cgi?id=283179
9	******************************************************************************/	11	******************************************************************************/
		12
10	package org.eclipse.zest.core.widgets;	13	package org.eclipse.zest.core.widgets;
11		14
12	import java.util.ArrayList;	15	import java.util.ArrayList;
Lines 14-74 Link Here
14	import java.util.LinkedList;	17	import java.util.LinkedList;
15	import java.util.List;	18	import java.util.List;
16		19
		20	import org.eclipse.draw2d.ActionEvent;
		21	import org.eclipse.draw2d.ActionListener;
17	import org.eclipse.draw2d.Animation;	22	import org.eclipse.draw2d.Animation;
		23	import org.eclipse.draw2d.Clickable;
18	import org.eclipse.draw2d.ColorConstants;	24	import org.eclipse.draw2d.ColorConstants;
		25	import org.eclipse.draw2d.Figure;
19	import org.eclipse.draw2d.FreeformLayout;	26	import org.eclipse.draw2d.FreeformLayout;
20	import org.eclipse.draw2d.FreeformViewport;	27	import org.eclipse.draw2d.FreeformViewport;
		28	import org.eclipse.draw2d.Graphics;
21	import org.eclipse.draw2d.IFigure;	29	import org.eclipse.draw2d.IFigure;
		30	import org.eclipse.draw2d.Label;
22	import org.eclipse.draw2d.LayoutAnimator;	31	import org.eclipse.draw2d.LayoutAnimator;
23	import org.eclipse.draw2d.LineBorder;	32	import org.eclipse.draw2d.LineBorder;
24	import org.eclipse.draw2d.PolylineConnection;
25	import org.eclipse.draw2d.ScrollPane;	33	import org.eclipse.draw2d.ScrollPane;
		34	import org.eclipse.draw2d.ToolbarLayout;
		35	import org.eclipse.draw2d.Triangle;
26	import org.eclipse.draw2d.Viewport;	36	import org.eclipse.draw2d.Viewport;
27	import org.eclipse.draw2d.geometry.Dimension;	37	import org.eclipse.draw2d.geometry.Dimension;
28	import org.eclipse.draw2d.geometry.Point;	38	import org.eclipse.draw2d.geometry.Point;
29	import org.eclipse.draw2d.geometry.Rectangle;	39	import org.eclipse.draw2d.geometry.Rectangle;
		40	import org.eclipse.swt.events.SelectionEvent;
		41	import org.eclipse.swt.events.SelectionListener;
		42	import org.eclipse.swt.graphics.Color;
30	import org.eclipse.swt.graphics.Image;	43	import org.eclipse.swt.graphics.Image;
		44	import org.eclipse.swt.graphics.RGB;
		45	import org.eclipse.swt.widgets.Display;
31	import org.eclipse.zest.core.widgets.internal.AspectRatioFreeformLayer;	46	import org.eclipse.zest.core.widgets.internal.AspectRatioFreeformLayer;
32	import org.eclipse.zest.core.widgets.internal.ContainerFigure;	47	import org.eclipse.zest.core.widgets.internal.ContainerFigure;
33	import org.eclipse.zest.core.widgets.internal.ExpandGraphLabel;
34	import org.eclipse.zest.core.widgets.internal.ZestRootLayer;	48	import org.eclipse.zest.core.widgets.internal.ZestRootLayer;
35	import org.eclipse.zest.layouts.InvalidLayoutConfiguration;
36	import org.eclipse.zest.layouts.LayoutAlgorithm;	49	import org.eclipse.zest.layouts.LayoutAlgorithm;
37	import org.eclipse.zest.layouts.LayoutEntity;
38	import org.eclipse.zest.layouts.LayoutRelationship;
39	import org.eclipse.zest.layouts.LayoutStyles;
40	import org.eclipse.zest.layouts.algorithms.TreeLayoutAlgorithm;	50	import org.eclipse.zest.layouts.algorithms.TreeLayoutAlgorithm;
		51	import org.eclipse.zest.layouts.dataStructures.DisplayIndependentRectangle;
41		52
42	/*	53	/**
43	* A Container than can be added to a Graph. Nodes can be added to this	54	* A Container that can be added to a Graph. Nodes can be added to this
44	* container. The container supports collapsing and expanding and has the same	55	* container. The container supports collapsing and expanding and has the same
45	* properties as the nodes. Containers cannot have custom figures.	56	* properties as the nodes. Containers cannot have custom figures.
46	*	57	*
47	* @author Ian Bull	58	* @author Ian Bull
48	*/	59	*/
49	public class GraphContainer extends GraphNode implements IContainer {	60	public class GraphContainer extends GraphNode {
		61
		62	public static class ExpandGraphLabel extends Figure implements ActionListener {
		63
		64	private boolean isExpanded;
		65	private Expander expander = new Expander();
		66	private Color darkerBackground;
		67
		68	class Expander extends Clickable {
		69	private Triangle triangle;
		70
		71	public Expander() {
		72	setStyle(Clickable.STYLE_TOGGLE);
		73	triangle = new Triangle();
		74	triangle.setSize(10, 10);
		75	triangle.setBackgroundColor(ColorConstants.black);
		76	triangle.setForegroundColor(ColorConstants.black);
		77	triangle.setFill(true);
		78	triangle.setDirection(Triangle.EAST);
		79	triangle.setLocation(new Point(5, 3));
		80	this.setLayoutManager(new FreeformLayout());
		81	this.add(triangle);
		82	this.setPreferredSize(15, 15);
		83	this.addActionListener(ExpandGraphLabel.this);
		84	}
		85
		86	public void open() {
		87	triangle.setDirection(Triangle.SOUTH);
		88	}
		89
		90	public void close() {
		91	triangle.setDirection(Triangle.EAST);
		92	}
		93
		94	}
		95
		96	/**
		97	* Sets the expander state (the little triangle) to
		98	* ExpanderGraphLabel.OPEN or ExpanderGraphLabel.CLOSED
		99	*
		100	* @param state
		101	*/
		102	public void setExpandedState(boolean expanded) {
		103	if (expanded) {
		104	expander.open();
		105	} else {
		106	expander.close();
		107	}
		108	this.isExpanded = expanded;
		109	}
		110
		111	/*
		112	* (non-Javadoc)
		113	*
		114	* @see
		115	* org.eclipse.draw2d.ActionListener#actionPerformed(org.eclipse.draw2d
		116	* .ActionEvent)
		117	*/
		118	public void actionPerformed(ActionEvent event) {
		119	if (isExpanded) {
		120	container.close(true);
		121	} else {
		122	container.open(true);
		123	}
		124	}
125
126	private final int arcWidth = 8;
127	private final Label label;
128	private final GraphContainer container;
129	private final ToolbarLayout layout;
130
131	public ExpandGraphLabel(GraphContainer container, String text, Image image, boolean cacheLabel) {
132	this.label = new Label(text) {
133
134	/**
135	* <b>This method is overwritten so that the text is not
136	* truncated.</b><br>
137	*
138	* {@inheritDoc}
139	*
140	*/
141	protected void paintFigure(Graphics graphics) {
142	if (isOpaque()) {
143	super.paintFigure(graphics);
144	}
145	Rectangle bounds = getBounds();
146	graphics.translate(bounds.x, bounds.y);
147	if (getIcon() != null) {
148	graphics.drawImage(getIcon(), getIconLocation());
149	}
150	if (!isEnabled()) {
151	graphics.translate(1, 1);
152	graphics.setForegroundColor(ColorConstants.buttonLightest);
153	graphics.drawText(getSubStringText(), getTextLocation());
154	graphics.translate(-1, -1);
155	graphics.setForegroundColor(ColorConstants.buttonDarker);
156	}
157	graphics.drawText(getText(), getTextLocation());
158	graphics.translate(-bounds.x, -bounds.y);
159	}
160	};
161	this.setText(text);
162	this.setImage(image);
163	this.container = container;
164	this.setFont(Display.getDefault().getSystemFont());
165	layout = new ToolbarLayout(true);
166	layout.setSpacing(5);
167	layout.setMinorAlignment(ToolbarLayout.ALIGN_CENTER);
168	this.setLayoutManager(layout);
169	this.add(this.expander);
170	this.add(this.label);
171	}
172
173	private Color getDarkerBackgroundColor() {
174	if (darkerBackground == null) {
175	Color baseColor = getBackgroundColor();
176	int blue = (int) (baseColor.getBlue() * 0.8 + 0.5);
177	int red = (int) (baseColor.getRed() * 0.8 + 0.5);
178	int green = (int) (baseColor.getGreen() * 0.8 + 0.5);
179	darkerBackground = new Color(Display.getCurrent(), new RGB(red, green, blue));
180	}
181	return darkerBackground;
182	}
183
184	/*
185	* (non-Javadoc)
186	*
187	* @see
188	* org.eclipse.draw2d.Label#paintFigure(org.eclipse.draw2d.Graphics)
189	*/
190	public void paint(Graphics graphics) {
191
192	graphics.setForegroundColor(getDarkerBackgroundColor());
193	graphics.setBackgroundColor(getBackgroundColor());
194
195	graphics.pushState();
196
197	// fill in the background
198	Rectangle bounds = getBounds().getCopy();
199	Rectangle r = bounds.getCopy();
200	r.y += arcWidth / 2;
201	r.height -= arcWidth;
202
203	Rectangle top = bounds.getCopy();
204	top.height /= 2;
205	graphics.setForegroundColor(getBackgroundColor());
206	graphics.setBackgroundColor(getBackgroundColor());
207	graphics.fillRoundRectangle(top, arcWidth, arcWidth);
208
209	top.y = top.y + top.height;
210	graphics.setForegroundColor(darkerBackground);
211	graphics.setBackgroundColor(darkerBackground);
212	graphics.fillRoundRectangle(top, arcWidth, arcWidth);
213
214	graphics.setBackgroundColor(darkerBackground);
215	graphics.setForegroundColor(getBackgroundColor());
216	graphics.fillGradient(r, true);
217
218	super.paint(graphics);
219	graphics.popState();
220	graphics.setForegroundColor(darkerBackground);
221	graphics.setBackgroundColor(darkerBackground);
222	// paint the border
223	bounds.setSize(bounds.width - 1, bounds.height - 1);
224	graphics.drawRoundRectangle(bounds, arcWidth, arcWidth);
225	}
226
227	public void setBackgroundColor(Color bg) {
228	super.setBackgroundColor(bg);
229	if (darkerBackground != null) {
230	darkerBackground.dispose();
231	}
232	darkerBackground = null;
233	}
234
235	public void setTextT(String string) {
236	this.setPreferredSize(null);
237	this.label.setText(string);
238	this.add(label);
239	this.layout.layout(this);
240	this.invalidate();
241	this.revalidate();
242	this.validate();
243	}
244
245	public void setText(String string) {
246	this.label.setText(string);
247	}
248
249	public void setImage(Image image) {
250	this.label.setIcon(image);
251	}
252
253	public void setFocus() {
254	expander.requestFocus();
255	}
256
257	}
50		258
51	//private static final double CONTAINER_SCALE = 0.75;	259	static final double SCALED_WIDTH = 300;
52	private static final double scaledWidth = 300;	260	static final double SCALED_HEIGHT = 200;
53	private static final double scaledHeight = 200;
54	private static final int CONTAINER_HEIGHT = 200;	261	private static final int CONTAINER_HEIGHT = 200;
55	private static final int MIN_WIDTH = 250;	262	private static final int MIN_WIDTH = 250;
		263	private static final int MIN_HEIGHT = 30;
56	private static final int ANIMATION_TIME = 100;	264	private static final int ANIMATION_TIME = 100;
57	private static final int SUBLAYER_OFFSET = 2;	265	private static final int SUBLAYER_OFFSET = 2;
58		266
		267	private static SelectionListener selectionListener;
		268
59	private ExpandGraphLabel expandGraphLabel;	269	private ExpandGraphLabel expandGraphLabel;
60		270
61	//private FreeformLayer container;
62	//private FreeformLayer edgeLayer;
63	private List childNodes = null;	271	private List childNodes = null;
64	private int childAreaHeight = CONTAINER_HEIGHT;	272	private int childAreaHeight = CONTAINER_HEIGHT;
65		273
66	public ZestRootLayer zestLayer;	274	private ZestRootLayer zestLayer;
67	private ScrollPane scrollPane;	275	private ScrollPane scrollPane;
68	private LayoutAlgorithm layoutAlgorithm;	276	private LayoutAlgorithm layoutAlgorithm;
69	private boolean isExpanded = false;	277	private boolean isExpanded = false;
70	//private ScalableFreeformLayeredPane scalledLayer;
71	private AspectRatioFreeformLayer scalledLayer;	278	private AspectRatioFreeformLayer scalledLayer;
		279	private InternalLayoutContext layoutContext;
72		280
73	/**	281	/**
74	* Creates a new GraphContainer. A GraphContainer may contain nodes,	282	* Creates a new GraphContainer. A GraphContainer may contain nodes,
Lines 76-96 Link Here
76	* @param graph The graph that the container is being added to	284	* @param graph The graph that the container is being added to
77	* @param style	285	* @param style
78	*/	286	*/
79	public GraphContainer(IContainer graph, int style) {	287	public GraphContainer(Graph graph, int style) {
80	this(graph, style, "");	288	this(graph, style, "");
		289	}
		290
		291	public GraphContainer(Graph graph, int style, String text) {
		292	this(graph, style, text, null);
		293	}
81		294
		295	public GraphContainer(Graph graph, int style, String text, Image image) {
		296	this(NodeContainerAdapter.get(graph), style, text, image);
82	}	297	}
83		298
84	public GraphContainer(IContainer graph, int style, String text) {	299	public GraphContainer(GraphContainer graph, int style) {
		300	this(graph, style, "");
		301	}
		302
		303	public GraphContainer(GraphContainer graph, int style, String text) {
85	this(graph, style, text, null);	304	this(graph, style, text, null);
		305	}
86		306
		307	public GraphContainer(GraphContainer graph, int style, String text, Image image) {
		308	this(NodeContainerAdapter.get(graph), style, text, image);
87	}	309	}
88		310
89	public GraphContainer(IContainer graph, int style, String text, Image image) {	311	public GraphContainer(NodeContainerAdapter graph, int style, String text, Image image) {
90	super(graph, style, text, image);	312	super(graph.getGraph(), style, text, image);
91	initModel(graph, text, image);	313	initModel(graph, text, image);
92	close(false);	314	close(false);
93	childNodes = new ArrayList();	315	childNodes = new ArrayList();
		316	registerToParent(graph);
94	}	317	}
95		318
96	/**	319	/**
Lines 100-119 Link Here
100	throw new RuntimeException("Operation not supported: Containers cannot have custom figures");	323	throw new RuntimeException("Operation not supported: Containers cannot have custom figures");
101	}	324	}
102		325
103	/*
104	* (non-Javadoc)
105	* @see org.eclipse.mylar.zest.core.widgets.GraphItem#getItemType()
106	public int getItemType() {
107	return GraphItem.CONTAINER;
108	}
109
110	/**
111	* Gets the figure for this container.
112	*/
113	public IFigure getNodeFigure() {
114	return this.nodeFigure;
115	}
116
117	/**	326	/**
118	* Close this node.	327	* Close this node.
119	* @param animate	328	* @param animate
Lines 124-139 Link Here
124	}	333	}
125	isExpanded = false;	334	isExpanded = false;
126		335
127	expandGraphLabel.setExpandedState(ExpandGraphLabel.CLOSED);	336	expandGraphLabel.setExpandedState(false);
128	Rectangle newBounds = scrollPane.getBounds().getCopy();	337	Rectangle newBounds = scrollPane.getBounds().getCopy();
129	newBounds.height = 0;	338	newBounds.height = 0;
130		339
131	//this.nodeFigure.setConstraint(scrollPane, newBounds);
132	//this.nodeFigure.revalidate();
133	scrollPane.setSize(scrollPane.getSize().width, 0);	340	scrollPane.setSize(scrollPane.getSize().width, 0);
134	updateFigureForModel(this.zestLayer);	341	updateFigureForModel(this.zestLayer);
135	scrollPane.setVisible(false);	342	scrollPane.setVisible(false);
136	//setSize(expandGraphLabel.getSize().width, expandGraphLabel.getSize().height);
137	List children = this.zestLayer.getChildren();	343	List children = this.zestLayer.getChildren();
138	for (Iterator iterator = children.iterator(); iterator.hasNext();) {	344	for (Iterator iterator = children.iterator(); iterator.hasNext();) {
139	IFigure child = (IFigure) iterator.next();	345	IFigure child = (IFigure) iterator.next();
Lines 145-151 Link Here
145	if (animate) {	351	if (animate) {
146	Animation.run(ANIMATION_TIME);	352	Animation.run(ANIMATION_TIME);
147	}	353	}
148	//this.nodeFigure.getUpdateManager().performUpdate();
149	updateFigureForModel(nodeFigure);	354	updateFigureForModel(nodeFigure);
150	}	355	}
151		356
Lines 235-241 Link Here
235	private void moveNodesUp(Rectangle containerBounds, GraphNode graphContainer) {	440	private void moveNodesUp(Rectangle containerBounds, GraphNode graphContainer) {
236		441
237	// Get all nodes below this container, in order	442	// Get all nodes below this container, in order
238	List orderedNodesBelowY = getOrderedNodesBelowY(parent.getNodes(), containerBounds.y, graphContainer);	443	List orderedNodesBelowY = getOrderedNodesBelowY(parent.getGraph().getNodes(), containerBounds.y, graphContainer);
239	int leftSide = containerBounds.x;	444	int leftSide = containerBounds.x;
240	int rightSide = containerBounds.x + containerBounds.width;	445	int rightSide = containerBounds.x + containerBounds.width;
241	List nodesToConsider = new LinkedList();	446	List nodesToConsider = new LinkedList();
Lines 292-302 Link Here
292	}	497	}
293	isExpanded = true;	498	isExpanded = true;
294		499
295	expandGraphLabel.setExpandedState(ExpandGraphLabel.OPEN);	500	expandGraphLabel.setExpandedState(true);
296		501
297	scrollPane.setSize(computeChildArea());	502	scrollPane.setSize(computeChildArea());
298	scrollPane.setVisible(true);	503	scrollPane.setVisible(true);
299	//setSize(expandGraphLabel.getSize().width, expandGraphLabel.getSize().height + expandedHeight - SUBLAYER_OFFSET);
300		504
301	List children = this.zestLayer.getChildren();	505	List children = this.zestLayer.getChildren();
302	for (Iterator iterator = children.iterator(); iterator.hasNext();) {	506	for (Iterator iterator = children.iterator(); iterator.hasNext();) {
Lines 308-323 Link Here
308	updateFigureForModel(nodeFigure);	512	updateFigureForModel(nodeFigure);
309		513
310	Rectangle containerBounds = new Rectangle(this.getLocation(), new Dimension(this.getSize().width, CONTAINER_HEIGHT + this.expandGraphLabel.getSize().height));	514	Rectangle containerBounds = new Rectangle(this.getLocation(), new Dimension(this.getSize().width, CONTAINER_HEIGHT + this.expandGraphLabel.getSize().height));
311	//moveIntersectedNodes(containerBounds, this);
312	moveNodesDown(containerBounds, this);	515	moveNodesDown(containerBounds, this);
313	moveNodesUp(containerBounds, this);	516	moveNodesUp(containerBounds, this);
314	//pack(graph);
315	if (animate) {	517	if (animate) {
316	Animation.run(ANIMATION_TIME);	518	Animation.run(ANIMATION_TIME);
317	}	519	}
318	this.getFigure().getUpdateManager().performValidation();	520	this.getFigure().getUpdateManager().performValidation();
319	//this.nodeFigure.getUpdateManager().performUpdate();
320
321	}	521	}
322		522
323	/**	523	/**
Lines 328-334 Link Here
328	private void moveNodesDown(Rectangle containerBounds, GraphContainer graphContainer) {	528	private void moveNodesDown(Rectangle containerBounds, GraphContainer graphContainer) {
329		529
330	// Find all nodes below here	530	// Find all nodes below here
331	List nodesBelowHere = getOrderedNodesBelowY(parent.getNodes(), containerBounds.y, graphContainer);	531	List nodesBelowHere = getOrderedNodesBelowY(parent.getGraph().getNodes(), containerBounds.y, graphContainer);
332	Iterator nodesBelowHereIterator = nodesBelowHere.iterator();	532	Iterator nodesBelowHereIterator = nodesBelowHere.iterator();
333	List nodesToMove = new LinkedList();	533	List nodesToMove = new LinkedList();
334	int left = containerBounds.x;	534	int left = containerBounds.x;
Lines 349-391 Link Here
349		549
350	}	550	}
351		551
352	void highlightNode(GraphNode node) {
353
354	}
355
356	void highlightEdge(GraphConnection connection) {
357	}
358
359	void highlightNode(GraphContainer container) {
360
361	}
362
363	void unhighlightNode(GraphNode node) {
364
365	}
366
367	void unhighlightNode(GraphContainer container) {
368
369	}
370
371	// /**
372	// * Gets a list of nodes below the given node
373	// * @param node
374	// * @return
375	// */
376	// private List getNodesBelow(int y, List nodes) {
377	// Iterator allNodes = nodes.iterator();
378	// LinkedList result = new LinkedList();
379	// while (allNodes.hasNext()) {
380	// GraphNode nextNode = (GraphNode) allNodes.next();
381	// int top = nextNode.getLocation().y;
382	// if (top > y) {
383	// result.add(nextNode);
384	// }
385	// }
386	// return result;
387	// }
388
389	/**	552	/**
390	* Checks all the nodes in the list of nodesToCheck to see if they intersect with the bounds set	553	* Checks all the nodes in the list of nodesToCheck to see if they intersect with the bounds set
391	* @param node	554	* @param node
Lines 439-561 Link Here
439	}	602	}
440	}	603	}
441		604
442	// /**
443	// * This finds the highest Y Value of a set of nodes.
444	// * @param nodes
445	// * @return
446	// */
447	// private int findSmallestYValue(List nodes) {
448	// Iterator iterator = nodes.iterator();
449	// int lowestNode /highest on the screen/= Integer.MAX_VALUE - 100; // Subtract 100 so we don't overflow
450	// while (iterator.hasNext()) {
451	// GraphNode node = (GraphNode) iterator.next();
452	// int y = node.getLocation().y;
453	// lowestNode = Math.min(lowestNode, y);
454	// }
455	// return lowestNode;
456	// }
457
458	// /**
459	// * Clears the nodes that the container intersects as it expands
460	// * @param containerBounds
461	// * @param graphContainer
462	// */
463	// private void moveIntersectedNodes(Rectangle containerBounds, GraphNode graphContainer) {
464	//
465	// List nodesBelowHere = getNodesBelow(this.getLocation().y, graphContainer.getGraphModel().getNodes());
466	// List intersectingNodes = intersectingNodes(containerBounds, nodesBelowHere, graphContainer);
467	// int delta = getMaxMovement(containerBounds, intersectingNodes);
468	// shiftNodesDown(intersectingNodes, delta);
469	//
470	// int lowestNode /highest on the screen/= findSmallestYValue(intersectingNodes);
471	// nodesBelowHere = getNodesBelow(lowestNode, nodesBelowHere);
472	//
473	// while (nodesBelowHere.size() > 0) {
474	// Iterator intersectingNodeIterator = intersectingNodes.iterator();
475	// List nodesMovedInLastIteration = new LinkedList();
476	// while (intersectingNodeIterator.hasNext()) {
477	// GraphNode node = (GraphNode) intersectingNodeIterator.next();
478	// intersectingNodes = intersectingNodes(node.getBounds(), nodesBelowHere, node);
479	// delta = getMaxMovement(node.getBounds(), intersectingNodes);
480	// if (delta > 0) {
481	// shiftNodesDown(intersectingNodes, delta);
482	// nodesMovedInLastIteration.addAll(intersectingNodes);
483	// }
484	// }
485	// lowestNode /highest on the screen/= findSmallestYValue(nodesMovedInLastIteration);
486	// nodesBelowHere = getNodesBelow(lowestNode, nodesBelowHere);
487	// intersectingNodes = nodesMovedInLastIteration;
488	// }
489	// }
490
491	/**	605	/**
492	* Gets the graph that this container has been added to.	606	* Gets the graph that this container has been added to.
493	*/	607	*/
494	public Graph getGraph() {	608	public Graph getGraph() {
495	return this.graph.getGraph();	609	return this.graph;
496	}	610	}
497		611
498	public int getItemType() {	612	public int getItemType() {
499	return CONTAINER;	613	return CONTAINER;
500	}	614	}
501		615
502	/**
503	*
504	*/
505	public void setLayoutAlgorithm(LayoutAlgorithm algorithm, boolean applyLayout) {	616	public void setLayoutAlgorithm(LayoutAlgorithm algorithm, boolean applyLayout) {
		617	if (this.layoutAlgorithm != null) {
		618	this.layoutAlgorithm.setLayoutContext(null);
		619	}
		620
506	this.layoutAlgorithm = algorithm;	621	this.layoutAlgorithm = algorithm;
		622	this.layoutAlgorithm.setLayoutContext(getLayoutContext());
507	if (applyLayout) {	623	if (applyLayout) {
508	applyLayout();	624	applyLayout();
509	}	625	}
510
511	}	626	}
512		627
513	public void applyLayout() {	628	InternalLayoutContext getLayoutContext() {
514	if ((this.getNodes().size() == 0)) {	629	if (layoutContext == null) {
515	return;	630	layoutContext = new InternalLayoutContext(this);
516	}	631	}
		632	return layoutContext;
		633	}
517		634
518	int layoutStyle = 0;	635	DisplayIndependentRectangle getLayoutBounds() {
519		636	double width = GraphContainer.SCALED_WIDTH - 10;
520	if (checkStyle(ZestStyles.NODES_NO_LAYOUT_RESIZE)) {	637	double height = GraphContainer.SCALED_HEIGHT - 10;
521	layoutStyle = LayoutStyles.NO_LAYOUT_NODE_RESIZING;	638	return new DisplayIndependentRectangle(25, 25, width - 50, height - 50);
522	}	639	}
523		640
		641	public void applyLayout() {
524	if (layoutAlgorithm == null) {	642	if (layoutAlgorithm == null) {
525	layoutAlgorithm = new TreeLayoutAlgorithm(layoutStyle);	643	setLayoutAlgorithm(new TreeLayoutAlgorithm(), false);
526	}
527
528	layoutAlgorithm.setStyle(layoutAlgorithm.getStyle() \| layoutStyle);
529
530	// calculate the size for the layout algorithm
531	//Dimension d = this.scalledLayer.getSize();
532	Dimension d = new Dimension();
533	d.width = (int) scaledWidth;
534	d.height = (int) scaledHeight;
535
536	d.width = d.width - 10;
537	d.height = d.height - 10;
538	//if (d.height <= 0) {
539	//d.height = (CONTAINER_HEIGHT);
540	//}
541	//d.scale(1 / this.scalledLayer.getScale());
542
543	if (d.isEmpty()) {
544	return;
545	}
546	LayoutRelationship[] connectionsToLayout = getGraph().getConnectionsToLayout(getNodes());
547	LayoutEntity[] nodesToLayout = getGraph().getNodesToLayout(getNodes());
548
549	try {
550	Animation.markBegin();
551	layoutAlgorithm.applyLayout(nodesToLayout, connectionsToLayout, 25, 25, d.width - 50, d.height - 50, false, false);
552	Animation.run(ANIMATION_TIME);
553	getFigure().getUpdateManager().performUpdate();
554
555	} catch (InvalidLayoutConfiguration e) {
556	e.printStackTrace();
557	}	644	}
558		645	Animation.markBegin();
		646	layoutAlgorithm.applyLayout();
		647	layoutContext.flushChanges(false);
		648	Animation.run(ANIMATION_TIME);
		649	getFigure().getUpdateManager().performUpdate();
559	}	650	}
560		651
561	/**	652	/**
Lines 616-651 Link Here
616	labelWidth = MIN_WIDTH;	707	labelWidth = MIN_WIDTH;
617	expandGraphLabel.setPreferredSize(labelWidth, labelHeight);	708	expandGraphLabel.setPreferredSize(labelWidth, labelHeight);
618	}	709	}
619	if (labelHeight < 30) {
620	labelHeight = 30;
621	}
622		710
623	dimension.labelHeight = labelHeight;	711	dimension.labelHeight = Math.max(labelHeight, MIN_HEIGHT);
624	dimension.width = labelWidth;	712	dimension.width = Math.max(labelWidth, this.size.width);
625	dimension.width = Math.max(dimension.width, this.size.width);	713	dimension.expandedHeight = Math.max(dimension.labelHeight + childAreaHeight - SUBLAYER_OFFSET, this.size.height);
626	dimension.expandedHeight = dimension.labelHeight + childAreaHeight - SUBLAYER_OFFSET;
627	dimension.expandedHeight = Math.max(dimension.expandedHeight, this.size.height);
628		714
629	return dimension;	715	return dimension;
630	}	716	}
631		717
632	/*
633	private double computeChildScale() {
634	Dimension childArea = computeChildArea();
635	double widthScale = childArea.width / scaledWidth;
636	double heightScale = childArea.height / scaledHeight;
637	return Math.min(widthScale, heightScale);
638	}
639	*/
640	private double computeHeightScale() {	718	private double computeHeightScale() {
641	Dimension childArea = computeChildArea();	719	Dimension childArea = computeChildArea();
642	double heightScale = childArea.height / scaledHeight;	720	double heightScale = childArea.height / SCALED_HEIGHT;
643	return heightScale;	721	return heightScale;
644	}	722	}
645		723
646	private double computeWidthScale() {	724	private double computeWidthScale() {
647	Dimension childArea = computeChildArea();	725	Dimension childArea = computeChildArea();
648	double widthScale = childArea.width / scaledWidth;	726	double widthScale = childArea.width / SCALED_WIDTH;
649	return widthScale;	727	return widthScale;
650	}	728	}
651		729
Lines 666-715 Link Here
666	scrollPane.addLayoutListener(LayoutAnimator.getDefault());	744	scrollPane.addLayoutListener(LayoutAnimator.getDefault());
667		745
668	Viewport viewport = new FreeformViewport();	746	Viewport viewport = new FreeformViewport();
669	/*
670	* This is the code that helps remove the scroll bars moving when the nodes
671	* are dragged.
672	*
673	viewport.setHorizontalRangeModel(new DefaultRangeModel() {
674	public void setAll(int min, int ext, int max) {
675	System.out.println("Max: " + max + " : current Max: " + getMaximum());
676	if (max < getMaximum()) {
677	max = getMaximum();
678	}
679	super.setAll(min, ext, max);
680	}
681
682	public void setMaximum(int maximum) {
683	// TODO Auto-generated method stub
684	System.out.println("Max: " + maximum + " : current Max: " + getMaximum());
685	if (maximum < getMaximum()) {
686	return;
687	}
688	super.setMaximum(maximum);
689	}
690	});
691	*/
692		747
693	scrollPane.setViewport(viewport);	748	scrollPane.setViewport(viewport);
694	viewport.addLayoutListener(LayoutAnimator.getDefault());	749	viewport.addLayoutListener(LayoutAnimator.getDefault());
695	scrollPane.setScrollBarVisibility(ScrollPane.AUTOMATIC);	750	scrollPane.setScrollBarVisibility(ScrollPane.AUTOMATIC);
696		751
697	//scalledLayer = new ScalableFreeformLayeredPane();
698	scalledLayer = new AspectRatioFreeformLayer("debug label");	752	scalledLayer = new AspectRatioFreeformLayer("debug label");
699	scalledLayer.addLayoutListener(LayoutAnimator.getDefault());	753	scalledLayer.addLayoutListener(LayoutAnimator.getDefault());
700	//scalledLayer.setScale(computeChildScale());
701	scalledLayer.setScale(computeWidthScale(), computeHeightScale());	754	scalledLayer.setScale(computeWidthScale(), computeHeightScale());
702	//container = new FreeformLayer();
703	//edgeLayer = new FreeformLayer();
704	zestLayer = new ZestRootLayer();	755	zestLayer = new ZestRootLayer();
705	zestLayer.addLayoutListener(LayoutAnimator.getDefault());	756	zestLayer.addLayoutListener(LayoutAnimator.getDefault());
706	//container.addLayoutListener(LayoutAnimator.getDefault());
707	//edgeLayer.addLayoutListener(LayoutAnimator.getDefault());
708	//scalledLayer.add(edgeLayer);
709	//scalledLayer.add(container);
710	scalledLayer.add(zestLayer);	757	scalledLayer.add(zestLayer);
711		758
712	//container.setLayoutManager(new FreeformLayout());
713	zestLayer.setLayoutManager(new FreeformLayout());	759	zestLayer.setLayoutManager(new FreeformLayout());
714	scrollPane.setSize(computeChildArea());	760	scrollPane.setSize(computeChildArea());
715	scrollPane.setLocation(new Point(0, containerDimension.labelHeight - SUBLAYER_OFFSET));	761	scrollPane.setLocation(new Point(0, containerDimension.labelHeight - SUBLAYER_OFFSET));
Lines 728-733 Link Here
728	return containerFigure;	774	return containerFigure;
729	}	775	}
730		776
		777	private void registerToParent(NodeContainerAdapter parent) {
		778	if (parent.getItemType() == GRAPH) {
		779	createSelectionListener();
		780	parent.getGraph().addSelectionListener(selectionListener);
		781	}
		782	}
		783
		784	private void createSelectionListener() {
		785	if (selectionListener == null) {
		786	selectionListener = new SelectionListener() {
		787	public void widgetSelected(SelectionEvent e) {
		788	if (e.item instanceof GraphContainer) {
		789	//set focus to expand label so that pressing space opens/closes
		790	//the last selected container
		791	((GraphContainer) e.item).expandGraphLabel.setFocus();
		792	}
		793	}
		794
		795	public void widgetDefaultSelected(SelectionEvent e) {
		796	// ignore
		797	}
		798	};
		799
		800	}
		801	}
		802
731	protected void updateFigureForModel(IFigure currentFigure) {	803	protected void updateFigureForModel(IFigure currentFigure) {
732		804
733	expandGraphLabel.setTextT(getText());	805	expandGraphLabel.setTextT(getText());
Lines 774-780 Link Here
774	refreshLocation();	846	refreshLocation();
775	figure.getUpdateManager().performValidation();	847	figure.getUpdateManager().performValidation();
776	*/	848	*/
777
778	}	849	}
779		850
780	protected void refreshLocation() {	851	protected void refreshLocation() {
Lines 803-835 Link Here
803	scalledLayer.setScale(computeWidthScale(), computeHeightScale());	874	scalledLayer.setScale(computeWidthScale(), computeHeightScale());
804	}	875	}
805		876
806	void addConnectionFigure(PolylineConnection connection) {	877	void addFigure(IFigure figure) {
807	nodeFigure.add(connection);	878	nodeFigure.add(figure);
808	//zestLayer.addConnection(connection);
809	}	879	}
810		880
811	void addNode(GraphNode node) {	881	void addNode(GraphNode node) {
812	zestLayer.addNode(node.getNodeFigure());	882	zestLayer.addNode(node.getNodeFigure());
813	this.childNodes.add(node);	883	this.childNodes.add(node);
814	//container.add(node.getNodeFigure());	884	node.setVisible(isExpanded);
815	//graph.registerItem(node);
816	}	885	}
817		886
818	void addNode(GraphContainer container) {	887	void addNode(GraphContainer container) {
819	// Containers cannot be added to other containers (yet)	888	throw new RuntimeException("Containers cannot be added to other containers (yet)");
820	}	889	}
821		890
822	public List getNodes() {	891	public List getNodes() {
823	return this.childNodes;	892	return this.childNodes;
824	}	893	}
825
826	void paint() {
827	Iterator iterator = getNodes().iterator();
828
829	while (iterator.hasNext()) {
830	GraphNode node = (GraphNode) iterator.next();
831	node.paint();
832	}
833	}
834
835	}	894	}




/*******************************************************************************
 * Copyright 2005-2007, CHISEL Group, University of Victoria, Victoria, BC, Canada.
 * 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:
 *     The Chisel Group, University of Victoria
 *******************************************************************************/
package org.eclipse.zest.core.widgets;

import java.util.List;

import org.eclipse.zest.layouts.LayoutAlgorithm;

/**
 * This interface describes all Zest components that are Containers. This is an internal interface
 * and thus should not be used outside of Zest.  Implementors of this interface must include the 
 * following two methods
 *   o addNode(GraphNode)
 *   o addNode(GraphContainer)
 *   
 * These are not actually listed here because Java does not allow protected methods in
 * interfaces.
 * 
 * @author Ian Bull
 */
public interface IContainer {

	public Graph getGraph();

	// All implementers must include this method
	/* protected void addNode(GraphNode node); */

	// All implementers must include this method
	/* protected void addNode(GraphContainer container); */

	public int getItemType();

	/**
	 * Re-applies the current layout algorithm
	 */
	public void applyLayout();

	/**
	 * Sets the LayoutAlgorithm for this container and optionally applies it.
	 *  
	 * @param algorithm The layout algorithm to set
	 * @param applyLayout 
	 */
	public void setLayoutAlgorithm(LayoutAlgorithm algorithm, boolean applyLayout);

	public List getNodes();

	/* protected void highlightNode(GraphNode node); */

	/* protected void highlightNode(GraphContainer container);*/

	/* protected void unhighlightNode(GraphNode node); */

	/* protected void unhighlightNode(GraphContainer container);*/

} // end of IContainer




/*******************************************************************************
 * Copyright 2005-2009, CHISEL Group, University of Victoria, Victoria, BC,
 * Canada. 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:
 *     The Chisel Group, University of Victoria
 *     Mateusz Matela <mateusz.matela@gmail.com> - Adapt Zest to changes in layout - https://bugs.eclipse.org/bugs/show_bug.cgi?id=283179
 ******************************************************************************/

package org.eclipse.zest.core.widgets;

import org.eclipse.draw2d.ChopboxAnchor;

import org.eclipse.zest.core.widgets.internal.PolylineArcConnection;
import org.eclipse.zest.core.widgets.internal.RoundedChopboxAnchor;
import org.eclipse.zest.core.widgets.internal.ZestRootLayer;
import org.eclipse.zest.layouts.ConnectionLayout;
import org.eclipse.zest.layouts.NodeLayout;
import org.eclipse.zest.layouts.LayoutRelationship;
import org.eclipse.zest.layouts.constraints.LayoutConstraint;

/**
 * This is the graph connection model which stores the source and destination
 * nodes and the properties of this connection (color, line width etc).
 * 

	private Color foreground;
	private int lineWidth;
	private int lineStyle;
	private final Graph graph;

	private int connectionStyle;
	private int curveDepth;

	private IFigure tooltip;

	private boolean highlighted;
	private GraphLayoutConnection layoutConnection = null;
	private boolean hasCustomTooltip;

	public GraphConnection(Graph graphModel, int style, GraphNode source, GraphNode destination) {

		this.highlightColor = graphModel.DARK_BLUE;
		this.lineWidth = 1;
		this.lineStyle = Graphics.LINE_SOLID;
		setWeight(1.0);
		this.graph = graphModel;
		this.curveDepth = 0;
		this.layoutConnection = new GraphLayoutConnection();
		this.font = Display.getDefault().getSystemFont();
		registerConnection(source, destination);
	}

		if (source.getParent().getItemType() == GraphItem.CONTAINER && destination.getParent().getItemType() == GraphItem.CONTAINER && (source.getParent() == destination.getParent())) {
			// 196189: Edges should not draw on the edge layer if both the src and dest are in the same container
			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=196189
			graph.addConnection(this, ZestRootLayer.EDGES_ON_TOP);
		} else {
			graph.addConnection(this, true);
		}

		if ((source.getParent()).getItemType() == GraphItem.CONTAINER) {
			// If the container of the source is a container, we need to draw another
			// arc on that arc layer
			sourceContainerConnectionFigure = doCreateFigure();
			((GraphContainer) source.getParent().getAdaptee()).addFigure(sourceContainerConnectionFigure);
			this.setVisible(false);
		}


			// If the container of the source is a container, we need to draw another
			// arc on that arc layer
			targetContainerConnectionFigure = doCreateFigure();
			((GraphContainer) destination.getParent().getAdaptee()).addFigure(targetContainerConnectionFigure);
			this.setVisible(false);
		}
		graph.registerItem(this);
	}

	void removeFigure() {

		this.isDisposed = true;
		(getSource()).removeSourceConnection(this);
		(getDestination()).removeTargetConnection(this);
		graph.removeConnection(this);
		if (sourceContainerConnectionFigure != null) {
			sourceContainerConnectionFigure.getParent().remove(sourceContainerConnectionFigure);
		}


	public Connection getConnectionFigure() {
		if (connectionFigure == null) {
			connectionFigure = doCreateFigure();
		}
		return connectionFigure;
	}

	/**
	 * Gets a proxy to this connection that can be used with the Zest layout
	 * engine
	 * 
	 * @return
	 */
	public LayoutRelationship getLayoutRelationship() {
		return this.layoutConnection;
	}

	/**
	 * Gets the external connection object.
	 * 
	 * @return Object

	 * @return String
	 */
	public String toString() {
		StringBuffer buffer = new StringBuffer("GraphModelConnection: ");
		buffer.append(sourceNode != null ? sourceNode.getText() : "null");
		buffer.append(isDirected() ? " --> " : " --- ");
		buffer.append(destinationNode != null ? destinationNode.getText() : "null");
		buffer.append("  (weight=").append(getWeightInLayout()).append(")");
		return buffer.toString();
	}

	/**

		}
		highlighted = true;
		updateFigure(connectionFigure);
		graph.highlightEdge(this);
	}

	/**

		}
		highlighted = false;
		updateFigure(connectionFigure);
		graph.unhighlightEdge(this);
	}

	/**

	 * @return The graph model that this connection is contained in
	 */
	public Graph getGraphModel() {
		return this.graph;
	}

	/**

		if (this.curveDepth == 0 && depth != 0 || this.curveDepth != 0 && depth == 0) {
			// There is currently no curve, so we have to create
			// a curved connection
			graph.removeConnection(this);
			this.curveDepth = depth;
			this.connectionFigure = doCreateFigure();
			registerConnection(sourceNode, destinationNode);
			updateFigure(this.connectionFigure);
		} else {

	 * @see org.eclipse.mylar.zest.core.internal.graphmodel.GraphItem#setVisible(boolean)
	 */
	public void setVisible(boolean visible) {
		//graphModel.addRemoveFigure(this, visible);
		if (getSource().isVisible() && getDestination().isVisible() && visible) {
			this.getFigure().setVisible(visible);
			if (sourceContainerConnectionFigure != null) {

		}
	}

	public boolean isDirected() {
		return ZestStyles.checkStyle(connectionStyle, ZestStyles.CONNECTIONS_DIRECTED);
	}

	public void setDirected(boolean directed) {
		if (directed) {
			setConnectionStyle(connectionStyle | ZestStyles.CONNECTIONS_DIRECTED);
		} else {
			setConnectionStyle(connectionStyle & (-1 - ZestStyles.CONNECTIONS_DIRECTED));
		}
	}

	PolylineConnection getSourceContainerConnectionFigure() {
		return (PolylineConnection) sourceContainerConnectionFigure;
	}

		connectionShape.setLineStyle(getLineStyle());

		if (this.getText() != null || this.getImage() != null) {
			//Label l = new Label(this.getText(), this.getImage());
			if (this.getImage() != null) {
				this.connectionLabel.setIcon(this.getImage());
			}

		connection.setToolTip(toolTip);
	}

	private Connection createFigure() {
		/*
		if ((sourceNode.getParent()).getItemType() == GraphItem.CONTAINER) {
			GraphContainer container = (GraphContainer) sourceNode.getParent();
			sourceContainerConnectionFigure = doCreateFigure();
			container.addConnectionFigure((PolylineConnection) sourceContainerConnectionFigure);
		}
		if ((destinationNode.getParent()).getItemType() == GraphItem.CONTAINER) {
			GraphContainer container = (GraphContainer) destinationNode.getParent();
			targetContainerConnectionFigure = doCreateFigure();
			container.addConnectionFigure((PolylineConnection) targetContainerConnectionFigure);
		}
		*/

		return doCreateFigure();

	}

	private Connection doCreateFigure() {
		Connection connectionFigure = null;
		ChopboxAnchor sourceAnchor = null;

		return connectionFigure;
	}

	IFigure getFigure() {
		return this.getConnectionFigure();
	 * 
	 * @see org.eclipse.mylar.zest.layouts.LayoutRelationship#isBidirectionalInLayout()
	 */
	private boolean isBidirectionalInLayout() {
		return !ZestStyles.checkStyle(connectionStyle, ZestStyles.CONNECTIONS_DIRECTED);
	}

	private InternalConnectionLayout layout;

		Object layoutInformation = null;

	InternalConnectionLayout getLayout() {
		if (layout == null) {
			layout = new InternalConnectionLayout();
		}
		return layout;
	}

	class InternalConnectionLayout implements ConnectionLayout {
		private boolean visible = GraphConnection.this.isVisible();
		}

		public NodeLayout getSource() {
			return sourceNode.getLayout();
		}

		public NodeLayout getTarget() {
			return destinationNode.getLayout();
		}

		public double getWeight() {
			return GraphConnection.this.getWeightInLayout();
		}

		public boolean isDirected() {
			return !ZestStyles.checkStyle(getConnectionStyle(), ZestStyles.CONNECTIONS_DIRECTED);
		}

		public boolean isVisible() {
			return visible;
		}

		public void setVisible(boolean visible) {
			this.visible = visible;
		}

		void applyLayout() {
			if (GraphConnection.this.isVisible() != this.visible) {
				GraphConnection.this.setVisible(this.visible);
			}
		}

	}

	void applyLayoutChanges() {
		if (layout != null) {
			layout.applyLayout();
		}
	}
}




/*******************************************************************************
 * Copyright 2005-2006, CHISEL Group, University of Victoria, Victoria, BC, Canada.
 * 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:
 *     The Chisel Group, University of Victoria
 *******************************************************************************/
package org.eclipse.zest.core.widgets;

import org.eclipse.zest.layouts.constraints.LayoutConstraint;

/**
 * 
 * This interface is used to populate layout constraints on Zest nodes.
 * Constraint will be a instance of LayoutConstraint (look at the heirarchy for an up-to-date list).
 * 
 * @author Ian Bull
 */
public interface ConstraintAdapter {
	
	/**
	 * 
	 * @param object
	 * @param constraint
	 */
	public void populateConstraint(Object object, LayoutConstraint constraint);

}

Lines 1-12 Link Here

(-)src/org/eclipse/zest/core/widgets/GraphItem.java (-4 / +7 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright 2005, CHISEL Group, University of Victoria, Victoria, BC, Canada.	2	* Copyright 2005-2009, CHISEL Group, University of Victoria, Victoria, BC,
3	* All rights reserved. This program and the accompanying materials are made	3	* Canada. All rights reserved. This program and the accompanying materials are
4	* available under the terms of the Eclipse Public License v1.0 which	4	* made available under the terms of the Eclipse Public License v1.0 which
5	* accompanies this distribution, and is available at	5	* accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*	7	*
8	* Contributors: The Chisel Group, University of Victoria	8	* Contributors:
		9	* The Chisel Group, University of Victoria
		10	* Mateusz Matela <mateusz.matela@gmail.com> - Adapt Zest to changes in layout - https://bugs.eclipse.org/bugs/show_bug.cgi?id=283179
9	******************************************************************************/	11	******************************************************************************/
		12
10	package org.eclipse.zest.core.widgets;	13	package org.eclipse.zest.core.widgets;
11		14
12	import org.eclipse.draw2d.IFigure;	15	import org.eclipse.draw2d.IFigure;

Lines 1-3 Link Here

(-)src/org/eclipse/zest/core/widgets/CGraphNode.java (-1 / +17 lines)
		1	/*******************************************************************************
		2	* Copyright 2005-2009, CHISEL Group, University of Victoria, Victoria, BC,
		3	* Canada. All rights reserved. This program and the accompanying materials are
		4	* made available under the terms of the Eclipse Public License v1.0 which
		5	* accompanies this distribution, and is available at
		6	* http://www.eclipse.org/legal/epl-v10.html
		7	*
		8	* Contributors:
		9	* The Chisel Group, University of Victoria
		10	* Mateusz Matela <mateusz.matela@gmail.com> - Adapt Zest to changes in layout - https://bugs.eclipse.org/bugs/show_bug.cgi?id=283179
		11	******************************************************************************/
		12
1	package org.eclipse.zest.core.widgets;	13	package org.eclipse.zest.core.widgets;
2		14
3	import org.eclipse.draw2d.IFigure;	15	import org.eclipse.draw2d.IFigure;
Lines 11-17 Link Here
11		23
12	IFigure figure = null;	24	IFigure figure = null;
13		25
14	public CGraphNode(IContainer graphModel, int style, IFigure figure) {	26	public CGraphNode(Graph graphModel, int style, IFigure figure) {
		27	super(graphModel, style, figure);
		28	}
		29
		30	public CGraphNode(GraphContainer graphModel, int style, IFigure figure) {
15	super(graphModel, style, figure);	31	super(graphModel, style, figure);
16	}	32	}
17		33




/*******************************************************************************
 * Copyright (c) 2009 Mateusz Matela 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:
 * 	   Mateusz Matela <mateusz.matela@gmail.com> - initial API and implementation
 *******************************************************************************/

package org.eclipse.zest.core.widgets;

import java.util.ArrayList;
import java.util.Iterator;

import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.draw2d.geometry.Point;
import org.eclipse.zest.layouts.ConnectionLayout;
import org.eclipse.zest.layouts.EntityLayout;
import org.eclipse.zest.layouts.NodeLayout;
import org.eclipse.zest.layouts.SubgraphLayout;
import org.eclipse.zest.layouts.dataStructures.DisplayIndependentDimension;
import org.eclipse.zest.layouts.dataStructures.DisplayIndependentPoint;

class InternalNodeLayout implements NodeLayout {
	private DisplayIndependentPoint location;
	private DisplayIndependentDimension size;
	private boolean minimized = false;
	private final GraphNode node;
	private final InternalLayoutContext ownerLayoutContext;
	private SubgraphLayout subgraph;

	public InternalNodeLayout(GraphNode graphNode) {
		this.node = graphNode;
		this.ownerLayoutContext = node.parent.getLayoutContext();
	}

	public DisplayIndependentPoint getLocation() {
		if (location == null) {
			Point location2 = node.getLocation();
			location = new DisplayIndependentPoint(location2.x + getSize().width / 2, location2.y + size.height / 2);
		}
		return new DisplayIndependentPoint(location);
	}

	public DisplayIndependentDimension getSize() {
		if (size == null) {
			Dimension size2 = node.getSize();
			size = new DisplayIndependentDimension(size2.width, size2.height);
		}
		return new DisplayIndependentDimension(size);
	}

	public SubgraphLayout getSubgraph() {
		return subgraph;
	}

	public boolean isMovable() {
		return true;
	}

	public boolean isPrunable() {
		return ownerLayoutContext.isPruningEnabled();
	}

	public boolean isPruned() {
		return subgraph != null;
	}

	public boolean isResizable() {
		return (node.parent.getAdaptee().getStyle() & ZestStyles.NODES_NO_LAYOUT_RESIZE) == 0;
	}

	public void prune(SubgraphLayout subgraph) {
		if (subgraph == this.subgraph) {
			return;
		}
		if (this.subgraph != null) {
			SubgraphLayout subgraph2 = this.subgraph;
			this.subgraph = null;
			subgraph2.removeNodes(new NodeLayout[] { this });
		}
		if (subgraph != null) {
			this.subgraph = subgraph;
			subgraph.addNodes(new NodeLayout[] { this });
		}
	}

	public void setLocation(double x, double y) {
		location = new DisplayIndependentPoint(x, y);
	}

	public void setSize(double width, double height) {
		size = new DisplayIndependentDimension(width, height);
	}

	public void setMinimized(boolean minimized) {
		getSize();
		this.minimized = minimized;
	}

	public boolean isMinimized() {
		return minimized;
	}

	public NodeLayout[] getPredecessingNodes() {
		ConnectionLayout[] connections = getIncomingConnections();
		NodeLayout[] result = new NodeLayout[connections.length];
		for (int i = 0; i < connections.length; i++) {
			result[i] = connections[i].getSource();
			if (result[i] == this) {
				result[i] = connections[i].getTarget();
			}
		}
		return result;
	}

	public NodeLayout[] getSuccessingNodes() {
		ConnectionLayout[] connections = getOutgoingConnections();
		NodeLayout[] result = new NodeLayout[connections.length];
		for (int i = 0; i < connections.length; i++) {
			result[i] = connections[i].getTarget();
			if (result[i] == this) {
				result[i] = connections[i].getSource();
			}
		}
		return result;
	}

	public EntityLayout[] getSuccessingEntities() {
		// TODO Auto-generated method stub
		return getSuccessingNodes();
	}

	public EntityLayout[] getPredecessingEntities() {
		// TODO Auto-generated method stub
		return getPredecessingNodes();
	}

	public ConnectionLayout[] getIncomingConnections() {
		ArrayList result = new ArrayList();
		for (Iterator iterator = node.getTargetConnections().iterator(); iterator.hasNext();) {
			GraphConnection connection = (GraphConnection) iterator.next();
			if (!ownerLayoutContext.isLayoutItemFiltered(connection)) {
				result.add(connection.getLayout());
			}
		}
		for (Iterator iterator = node.getSourceConnections().iterator(); iterator.hasNext();) {
			GraphConnection connection = (GraphConnection) iterator.next();
			if (!connection.isDirected() && !ownerLayoutContext.isLayoutItemFiltered(connection)) {
				result.add(connection.getLayout());
			}
		}
		return (ConnectionLayout[]) result.toArray(new ConnectionLayout[result.size()]);
	}

	public ConnectionLayout[] getOutgoingConnections() {
		ArrayList result = new ArrayList();
		for (Iterator iterator = node.getSourceConnections().iterator(); iterator.hasNext();) {
			GraphConnection connection = (GraphConnection) iterator.next();
			if (!ownerLayoutContext.isLayoutItemFiltered(connection)) {
				result.add(connection.getLayout());
			}
		}
		for (Iterator iterator = node.getTargetConnections().iterator(); iterator.hasNext();) {
			GraphConnection connection = (GraphConnection) iterator.next();
			if (!connection.isDirected() && !ownerLayoutContext.isLayoutItemFiltered(connection)) {
				result.add(connection.getLayout());
			}
		}
		return (ConnectionLayout[]) result.toArray(new ConnectionLayout[result.size()]);
	}

	public double getPreferredAspectRatio() {
		return 0;
	}

	void applyLayout() {
		if (minimized) {
			node.setSize(0, 0);
			if (location != null) {
				node.setLocation(location.x, location.y);
			}
		} else {
			if (location != null) {
				node.setLocation(location.x - getSize().width / 2, location.y - size.height / 2);
			}
			if (size != null) {
				node.setSize(size.width, size.height);
			}
		}
	}

	InternalLayoutContext getOwnerLayoutContext() {
		return ownerLayoutContext;
	}

	public String toString() {
		return node.toString() + "(layout)";
	}
}




/*******************************************************************************
 * Copyright 2005, 2009 CHISEL Group, University of Victoria, Victoria, BC, Canada.
 * 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:
 *     The Chisel Group, University of Victoria
 *     Mateusz Matela <mateusz.matela@gmail.com> - Adapt Zest to changes in layout - https://bugs.eclipse.org/bugs/show_bug.cgi?id=283179
 *******************************************************************************/
package org.eclipse.zest.core.widgets;

/**
 * A filter is used to filter objects.  Once implemented, interested
 * parties can ask this filter whether or not a specific object
 * is filtered.
 * 
 * For example, in a visualization tool, only unfiltered objects should
 * be displayed.  Before displaying an object, the display can ask
 * this filter if the object is filtered.
 * 
 * @author Casey Best
 */
public interface LayoutFilter {

	/**
	 * Returns true if the object is filtered, or false if it's not filtered.
	 * 
	 * @param item
	 *            object to check
	 * @return
	 */
	public boolean isObjectFiltered(GraphItem item);
}




/*******************************************************************************
 * Copyright (c) 2009 Mateusz Matela 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:
 * 	   Mateusz Matela <mateusz.matela@gmail.com> - initial API and implementation
 *******************************************************************************/

package org.eclipse.zest.core.widgets;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import org.eclipse.draw2d.Animation;
import org.eclipse.zest.layouts.ConnectionLayout;
import org.eclipse.zest.layouts.ContextListener;
import org.eclipse.zest.layouts.EntityLayout;
import org.eclipse.zest.layouts.ExpandCollapseManager;
import org.eclipse.zest.layouts.GraphStructureListener;
import org.eclipse.zest.layouts.LayoutAlgorithm;
import org.eclipse.zest.layouts.LayoutContext;
import org.eclipse.zest.layouts.LayoutListener;
import org.eclipse.zest.layouts.NodeLayout;
import org.eclipse.zest.layouts.SubgraphLayout;
import org.eclipse.zest.layouts.dataStructures.DisplayIndependentRectangle;

class InternalLayoutContext implements LayoutContext {

	final NodeContainerAdapter container;
	private List filters = new ArrayList();
	private List contextListeners = new ArrayList();
	private List graphStructureListeners = new ArrayList();
	private List layoutListeners = new ArrayList();
	private List pruningListeners = new ArrayList();
	private LayoutAlgorithm mainAlgorithm;
	private ExpandCollapseManager expandCollapseManager;
	private ArrayList subgraphs = new ArrayList();

	private final LayoutFilter defaultFilter = new LayoutFilter() {
		public boolean isObjectFiltered(GraphItem item) {
			// filter out invisible elements
			if (item instanceof GraphItem && ZestStyles.checkStyle(container.getGraph().getStyle(), ZestStyles.IGNORE_INVISIBLE_LAYOUT) && !(item).isVisible()) {
				return true;
			}
			return false;
		}
	};

	/**
	 * @param graph
	 *            the graph owning this context
	 */
	InternalLayoutContext(Graph graph) {
		this.container = NodeContainerAdapter.get(graph);
		addFilter(defaultFilter);
	}

	InternalLayoutContext(GraphContainer container) {
		this.container = NodeContainerAdapter.get(container);
		addFilter(defaultFilter);
	}

	public void addContextListener(ContextListener listener) {
		contextListeners.add(listener);
	}

	public void addGraphStructureListener(GraphStructureListener listener) {
		graphStructureListeners.add(listener);
	}

	public void addLayoutListener(LayoutListener listener) {
		layoutListeners.add(listener);
	}

	public SubgraphLayout addSubgraph(NodeLayout[] nodes) {
		// TODO Auto-generated method stub
		return null;
	}

	public void flushChanges(boolean animationHint) {
		// TODO Auto-generated method stub
		// TODO probably OK for nodes, need to add subgraphs
		// TODO support for asynchronous call
		animationHint = animationHint && container.getGraph().isVisible();
		if (animationHint) {
			Animation.markBegin();
		}
		for (Iterator iterator = container.getNodes().iterator(); iterator.hasNext();) {
			GraphNode node = (GraphNode) iterator.next();
			node.applyLayoutChanges();
		}
		for (Iterator iterator = container.getConnections().iterator(); iterator.hasNext();) {
			GraphConnection connection = (GraphConnection) iterator.next();
			connection.applyLayoutChanges();
		}
		if (animationHint) {
			Animation.run(Graph.ANIMATION_TIME);
		}
	}

	public DisplayIndependentRectangle getBounds() {
		return container.getLayoutBounds();
	}

	public LayoutAlgorithm getMainLayoutAlgorithm() {
		return mainAlgorithm;
	}

	public ExpandCollapseManager getExpandCollapseManager() {
		return expandCollapseManager;
	}

	public NodeLayout[] getNodes() {
		ArrayList result = new ArrayList();
		for (Iterator iterator = this.container.getNodes().iterator(); iterator.hasNext();) {
			GraphNode node = (GraphNode) iterator.next();
			if (!isLayoutItemFiltered(node)) {
				result.add(node.getLayout());
			}
		}
		return (NodeLayout[]) result.toArray(new NodeLayout[result.size()]);
	}

	public EntityLayout[] getEntities() {
		// TODO Auto-generated method stub
		return getNodes();
	}

	public SubgraphLayout[] getSubgraphs() {
		// TODO filter out subgraphs that have all elements filtered out
		return (SubgraphLayout[]) subgraphs.toArray(new SubgraphLayout[subgraphs.size()]);
	}

	public boolean isBoundsExpandable() {
		return false;
	}

	public boolean isContinuousLayoutEnabled() {
		return false;
	}

	public boolean isPruningEnabled() {
		return expandCollapseManager != null;
	}

	public void removeContextListener(ContextListener listener) {
		contextListeners.remove(listener);
	}

	public void removeGraphStructureListener(GraphStructureListener listener) {
		graphStructureListeners.remove(listener);
	}

	public void removeLayoutListener(LayoutListener listener) {
		layoutListeners.remove(listener);
	}

	public void setMainLayoutAlgorithm(LayoutAlgorithm algorithm) {
		mainAlgorithm = algorithm;
	}

	public void setExpandCollapseManager(ExpandCollapseManager pruningManager) {
		this.expandCollapseManager = pruningManager;
	}

	public ConnectionLayout[] getConnections() {
		List connections = container.getConnections();
		ConnectionLayout[] result = new ConnectionLayout[connections.size()];
		int i = 0;
		for (Iterator iterator = connections.iterator(); iterator.hasNext();) {
			GraphConnection connection = (GraphConnection) iterator.next();
			if (!isLayoutItemFiltered(connection)) {
				result[i++] = connection.getLayout();
			}
		}
		if (i == result.length) {
			return result;
		}
		ConnectionLayout[] result2 = new ConnectionLayout[i];
		System.arraycopy(result, 0, result2, 0, i);
		return result2;
	}

	public ConnectionLayout[] getConnections(EntityLayout source, EntityLayout target) {
		HashSet result = new HashSet();
		// TODO add support for subgraphs
		if (source instanceof NodeLayout && target instanceof NodeLayout) {
			ConnectionLayout[] outgoingConnections = ((NodeLayout) source).getOutgoingConnections();
			for (int i = 0; i < outgoingConnections.length; i++) {
				ConnectionLayout connection = outgoingConnections[i];
				if ((connection.getTarget() == target && connection.getSource() == source) || (connection.getTarget() == source && connection.getSource() == target)) {
					result.add(connection);
				}
			}
		}
		return (ConnectionLayout[]) result.toArray(new ConnectionLayout[result.size()]);
	}

	void addFilter(LayoutFilter filter) {
		filters.add(filter);
	}

	void removeFilter(LayoutFilter filter) {
		filters.remove(filter);
	}

	boolean isLayoutItemFiltered(GraphItem item) {
		for (Iterator it = filters.iterator(); it.hasNext();) {
			LayoutFilter filter = (LayoutFilter) it.next();
			if (filter.isObjectFiltered(item)) {
				return true;
			}
		}
		return false;
	}

	void setExpanded(NodeLayout node, boolean expanded) {
		if (expandCollapseManager != null) {
			expandCollapseManager.setExpanded(node, expanded);
		}
	}

	void applyMainAlgorithm() {
		if (mainAlgorithm != null) {
			mainAlgorithm.applyLayout();
			flushChanges(false);
		}
	}

	void fireNodeAddedEvent(NodeLayout node) {
		boolean intercepted = false;
		for (Iterator iterator = graphStructureListeners.iterator(); iterator.hasNext() && !intercepted;) {
			GraphStructureListener listener = (GraphStructureListener) iterator.next();
			intercepted = listener.nodeAdded(this, node);
		}
		if (!intercepted && mainAlgorithm != null) {
			mainAlgorithm.applyLayout();
		}
	}

	void fireNodeRemovedEvent(NodeLayout node) {
		boolean intercepted = false;
		for (Iterator iterator = graphStructureListeners.iterator(); iterator.hasNext() && !intercepted;) {
			GraphStructureListener listener = (GraphStructureListener) iterator.next();
			intercepted = listener.nodeRemoved(this, node);
		}
		if (!intercepted) {
			applyMainAlgorithm();
		}
	}

	void fireConnectionAddedEvent(ConnectionLayout connection) {
		InternalLayoutContext sourceContext = ((InternalNodeLayout) connection.getSource()).getOwnerLayoutContext();
		InternalLayoutContext targetContext = ((InternalNodeLayout) connection.getTarget()).getOwnerLayoutContext();
		if (sourceContext != targetContext) {
			return;
		}
		if (sourceContext == this) {
			boolean intercepted = false;
			for (Iterator iterator = graphStructureListeners.iterator(); iterator.hasNext() && !intercepted;) {
				GraphStructureListener listener = (GraphStructureListener) iterator.next();
				intercepted = listener.connectionAdded(this, connection);
			}
			if (!intercepted) {
				applyMainAlgorithm();
			}
		} else {
			sourceContext.fireConnectionAddedEvent(connection);
		}
	}

	void fireConnectionRemovedEvent(ConnectionLayout connection) {
		InternalLayoutContext sourceContext = ((InternalNodeLayout) connection.getSource()).getOwnerLayoutContext();
		InternalLayoutContext targetContext = ((InternalNodeLayout) connection.getTarget()).getOwnerLayoutContext();
		if (sourceContext != targetContext) {
			return;
		}
		if (sourceContext == this) {
			boolean intercepted = false;
			for (Iterator iterator = graphStructureListeners.iterator(); iterator.hasNext() && !intercepted;) {
				GraphStructureListener listener = (GraphStructureListener) iterator.next();
				intercepted = listener.connectionRemoved(this, connection);
			}
			if (!intercepted) {
				applyMainAlgorithm();
			}
		} else {
			sourceContext.fireConnectionAddedEvent(connection);
		}
	}

	void fireBoundsChangedEvent() {
		boolean intercepted = false;
		for (Iterator iterator = contextListeners.iterator(); iterator.hasNext() && !intercepted;) {
			ContextListener listener = (ContextListener) iterator.next();
			intercepted = listener.boundsChanged(this);
		}
		if (!intercepted) {
			applyMainAlgorithm();
		}
	}
}




/*******************************************************************************
 * Copyright (c) 2009 Mateusz Matela 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:
 * 	   Mateusz Matela <mateusz.matela@gmail.com> - initial API and implementation
 *******************************************************************************/

package org.eclipse.zest.core.widgets;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;

import org.eclipse.draw2d.IFigure;
import org.eclipse.draw2d.geometry.Dimension;
import org.eclipse.swt.widgets.Widget;
import org.eclipse.zest.layouts.dataStructures.DisplayIndependentRectangle;

/**
 * This adapter unifies API of {@link Graph} and {@link GraphContainer} and
 * is used everywhere objects of both these classes can be expected.
 * 
 * It's introduced in order to prevent some methods from change to public with
 * common interface.
 */
abstract class NodeContainerAdapter {
	private static class GraphAdapter extends NodeContainerAdapter {
		private Graph graph;

		private GraphAdapter(Graph graph) {
			graph.getStyle();
			this.graph = graph;
		}

		public Widget getAdaptee() {
			return graph;
		}

		public Graph getGraph() {
			return graph;
		}

		public List getNodes() {
			return graph.getNodes();
		}

		public List getConnections() {
			return filterConnections(graph.getConnections());
		}

		public void addNode(GraphNode graphNode) {
			graph.addNode(graphNode);
		}

		public void addFigure(IFigure figure) {
			graph.addFigure(figure);
		}

		public void highlightNode(GraphNode graphNode) {
			graph.highlightNode(graphNode);
		}

		public void unhighlightNode(GraphNode graphNode) {
			graph.highlightNode(graphNode);
		}

		public int getItemType() {
			return GraphItem.GRAPH;
		}

		public DisplayIndependentRectangle getLayoutBounds() {
			Dimension preferredSize = graph.getPreferredSize();
			return new DisplayIndependentRectangle(0, 0, preferredSize.width, preferredSize.height);
		}

		public InternalLayoutContext getLayoutContext() {
			return graph.getLayoutContext();
		}
	}

	private static class GraphContainerAdapter extends NodeContainerAdapter {
		private GraphContainer container;

		private GraphContainerAdapter(GraphContainer container) {
			this.container = container;
		}

		public Widget getAdaptee() {
			return container;
		}

		public Graph getGraph() {
			return container.getGraph();
		}

		public List getNodes() {
			return container.getNodes();
		}

		public List getConnections() {
			return filterConnections(container.getGraph().getConnections());
		}

		public void addNode(GraphNode graphNode) {
			container.addNode(graphNode);
		}

		public void addFigure(IFigure figure) {
			container.addFigure(figure);
		}

		public void highlightNode(GraphNode graphNode) {
			/* do nothing */
		}

		public void unhighlightNode(GraphNode graphNode) {
			/* do nothing */
		}

		public int getItemType() {
			return GraphItem.CONTAINER;
		}

		public DisplayIndependentRectangle getLayoutBounds() {
			return container.getLayoutBounds();
		}

		public InternalLayoutContext getLayoutContext() {
			return container.getLayoutContext();
		}
	}

	private static HashMap adaptersMap = new HashMap();

	static NodeContainerAdapter get(Graph graph) {
		NodeContainerAdapter adapter = (NodeContainerAdapter) adaptersMap.get(graph);
		if (adapter != null) {
			return adapter;
		}

		adapter = new GraphAdapter(graph);
		adaptersMap.put(graph, adapter);
		return adapter;
	}

	static NodeContainerAdapter get(GraphContainer container) {
		NodeContainerAdapter adapter = (NodeContainerAdapter) adaptersMap.get(container);
		if (adapter != null) {
			return adapter;
		}

		adapter = new GraphContainerAdapter(container);
		adaptersMap.put(container, adapter);
		return adapter;
	}

	public abstract Widget getAdaptee();

	public abstract Graph getGraph();

	public abstract List getNodes();

	/**
	 * Returns list of connections laying inside this container. Only
	 * connections which both source and target nodes lay directly in this
	 * container are returned.
	 * 
	 * @return
	 */
	public abstract List getConnections();

	public abstract void addNode(GraphNode graphNode);

	/**
	 * Adds a custom figure to be displayed on top of nodes. Can be used to add
	 * subgraph figures.
	 * 
	 * @param figure
	 */
	public abstract void addFigure(IFigure figure);

	public abstract void highlightNode(GraphNode graphNode);

	public abstract void unhighlightNode(GraphNode graphNode);

	public abstract int getItemType();

	public abstract DisplayIndependentRectangle getLayoutBounds();

	public abstract InternalLayoutContext getLayoutContext();

	/**
	 * Takes a list of connections and returns only those which source and
	 * target nodes lay directly in this container.
	 * 
	 * @param connections
	 *            list of GraphConnection to filter
	 * @return filtered list
	 */
	protected List filterConnections(List connections) {
		List result = new ArrayList();
		for (Iterator iterator = connections.iterator(); iterator.hasNext();) {
			GraphConnection connection = (GraphConnection) iterator.next();
			if (connection.getSource().getParent() == this && connection.getDestination().getParent() == this) {
				result.add(connection);
			}
		}
		return result;
	}
}

Return to bug 283179

Lines 1-11 Link Here

(-)src/org/eclipse/zest/core/viewers/internal/AbstractStructuredGraphViewer.java (-39 / +6 lines)
1	/*******************************************************************************	1	/*******************************************************************************
2	* Copyright 2005-2006, CHISEL Group, University of Victoria, Victoria, BC,	2	* Copyright 2005-2009, CHISEL Group, University of Victoria, Victoria, BC,
3	* Canada. All rights reserved. This program and the accompanying materials are	3	* Canada. All rights reserved. This program and the accompanying materials are
4	* made available under the terms of the Eclipse Public License v1.0 which	4	* made available under the terms of the Eclipse Public License v1.0 which
5	* accompanies this distribution, and is available at	5	* accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html	6	* http://www.eclipse.org/legal/epl-v10.html
7	*	7	*
8	* Contributors: The Chisel Group, University of Victoria	8	* Contributors:
		9	* The Chisel Group, University of Victoria
		10	* Mateusz Matela <mateusz.matela@gmail.com> - Adapt Zest to changes in layout - https://bugs.eclipse.org/bugs/show_bug.cgi?id=283179
9	******************************************************************************/	11	******************************************************************************/
10	package org.eclipse.zest.core.viewers.internal;	12	package org.eclipse.zest.core.viewers.internal;
11		13
Lines 26-42 Link Here
26	import org.eclipse.zest.core.viewers.AbstractZoomableViewer;	28	import org.eclipse.zest.core.viewers.AbstractZoomableViewer;
27	import org.eclipse.zest.core.viewers.IGraphContentProvider;	29	import org.eclipse.zest.core.viewers.IGraphContentProvider;
28	import org.eclipse.zest.core.widgets.CGraphNode;	30	import org.eclipse.zest.core.widgets.CGraphNode;
29	import org.eclipse.zest.core.widgets.ConstraintAdapter;
30	import org.eclipse.zest.core.widgets.Graph;	31	import org.eclipse.zest.core.widgets.Graph;
31	import org.eclipse.zest.core.widgets.GraphConnection;	32	import org.eclipse.zest.core.widgets.GraphConnection;
32	import org.eclipse.zest.core.widgets.GraphContainer;	33	import org.eclipse.zest.core.widgets.GraphContainer;
33	import org.eclipse.zest.core.widgets.GraphItem;	34	import org.eclipse.zest.core.widgets.GraphItem;
34	import org.eclipse.zest.core.widgets.GraphNode;	35	import org.eclipse.zest.core.widgets.GraphNode;
35	import org.eclipse.zest.core.widgets.IContainer;
36	import org.eclipse.zest.core.widgets.ZestStyles;	36	import org.eclipse.zest.core.widgets.ZestStyles;
37	import org.eclipse.zest.layouts.LayoutAlgorithm;	37	import org.eclipse.zest.layouts.LayoutAlgorithm;
38		38
39	/*	39	/**
40	* Abstraction of graph viewers to implement functionality used by all of them.	40	* Abstraction of graph viewers to implement functionality used by all of them.
41	* Not intended to be implemented by clients. Use one of the provided children	41	* Not intended to be implemented by clients. Use one of the provided children
42	* instead.	42	* instead.
Lines 65-75 Link Here
65	private HashMap connectionsMap = new HashMap();	65	private HashMap connectionsMap = new HashMap();
66		66
67	/**	67	/**
68	* The constraint adatpers
69	*/
70	private List constraintAdapters = new ArrayList();
71
72	/**
73	* A simple graph comparator that orders graph elements based on thier type	68	* A simple graph comparator that orders graph elements based on thier type
74	* (connection or node), and their unique object identification.	69	* (connection or node), and their unique object identification.
75	*/	70	*/
Lines 179-202 Link Here
179	}	174	}
180		175
181	/**	176	/**
182	* Adds a new constraint adapter to the list of constraints
183	*
184	* @param constraintAdapter
185	*/
186	public void addConstraintAdapter(ConstraintAdapter constraintAdapter) {
187	this.constraintAdapters.add(constraintAdapter);
188	}
189
190	/**
191	* Gets all the constraint adapters currently on the viewer
192	*
193	* @return
194	*/
195	public List getConstraintAdapters() {
196	return this.constraintAdapters;
197	}
198
199	/**
200	* Sets the layout algorithm for this viewer. Subclasses may place	177	* Sets the layout algorithm for this viewer. Subclasses may place
201	* restrictions on the algorithms that it accepts.	178	* restrictions on the algorithms that it accepts.
202	*	179	*
Lines 246-252 Link Here
246	return node;	223	return node;
247	}	224	}
248		225
249	GraphNode addGraphModelNode(IContainer container, Object element) {	226	GraphNode addGraphModelNode(GraphContainer container, Object element) {
250	GraphNode node = this.getGraphModelNode(element);	227	GraphNode node = this.getGraphModelNode(element);
251	if (node == null) {	228	if (node == null) {
252	node = new GraphNode(container, SWT.NONE);	229	node = new GraphNode(container, SWT.NONE);
Lines 646-655 Link Here
646	GraphConnection relationship = (GraphConnection) connectionsMap.get(connection);	623	GraphConnection relationship = (GraphConnection) connectionsMap.get(connection);
647		624
648	if (relationship != null) {	625	if (relationship != null) {
649	// remove the relationship from the layout algorithm
650	if (getLayoutAlgorithm() != null) {
651	getLayoutAlgorithm().removeRelationship(relationship.getLayoutRelationship());
652	}
653	// remove the relationship from the model	626	// remove the relationship from the model
654	relationship.dispose();	627	relationship.dispose();
655	}	628	}
Lines 679-690 Link Here
679	GraphNode node = (GraphNode) nodesMap.get(element);	652	GraphNode node = (GraphNode) nodesMap.get(element);
680		653
681	if (node != null) {	654	if (node != null) {
682	// remove the node from the layout algorithm and all the connections
683	if (getLayoutAlgorithm() != null) {
684	getLayoutAlgorithm().removeEntity(node.getLayoutEntity());
685	getLayoutAlgorithm().removeRelationships(node.getSourceConnections());
686	getLayoutAlgorithm().removeRelationships(node.getTargetConnections());
687	}
688	// remove the node and it's connections from the model	655	// remove the node and it's connections from the model
689	node.dispose();	656	node.dispose();
690	}	657	}

Removed Link Here

(-)src/org/eclipse/zest/core/widgets/IContainer.java (-64 lines)
1	/*******************************************************************************
2	* Copyright 2005-2007, CHISEL Group, University of Victoria, Victoria, BC, Canada.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* The Chisel Group, University of Victoria
10	*******************************************************************************/
11	package org.eclipse.zest.core.widgets;
12
13	import java.util.List;
14
15	import org.eclipse.zest.layouts.LayoutAlgorithm;
16
17	/**
18	* This interface describes all Zest components that are Containers. This is an internal interface
19	* and thus should not be used outside of Zest. Implementors of this interface must include the
20	* following two methods
21	* o addNode(GraphNode)
22	* o addNode(GraphContainer)
23	*
24	* These are not actually listed here because Java does not allow protected methods in
25	* interfaces.
26	*
27	* @author Ian Bull
28	*/
29	public interface IContainer {
30
31	public Graph getGraph();
32
33	// All implementers must include this method
34	/* protected void addNode(GraphNode node); */
35
36	// All implementers must include this method
37	/* protected void addNode(GraphContainer container); */
38
39	public int getItemType();
40
41	/**
42	* Re-applies the current layout algorithm
43	*/
44	public void applyLayout();
45
46	/**
47	* Sets the LayoutAlgorithm for this container and optionally applies it.
48	*
49	* @param algorithm The layout algorithm to set
50	* @param applyLayout
51	*/
52	public void setLayoutAlgorithm(LayoutAlgorithm algorithm, boolean applyLayout);
53
54	public List getNodes();
55
56	/* protected void highlightNode(GraphNode node); */
57
58	/* protected void highlightNode(GraphContainer container);*/
59
60	/* protected void unhighlightNode(GraphNode node); */
61
62	/* protected void unhighlightNode(GraphContainer container);*/
63
64	} // end of IContainer

Removed Link Here

(-)src/org/eclipse/zest/core/widgets/ConstraintAdapter.java (-31 lines)
1	/*******************************************************************************
2	* Copyright 2005-2006, CHISEL Group, University of Victoria, Victoria, BC, Canada.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* The Chisel Group, University of Victoria
10	*******************************************************************************/
11	package org.eclipse.zest.core.widgets;
12
13	import org.eclipse.zest.layouts.constraints.LayoutConstraint;
14
15	/**
16	*
17	* This interface is used to populate layout constraints on Zest nodes.
18	* Constraint will be a instance of LayoutConstraint (look at the heirarchy for an up-to-date list).
19	*
20	* @author Ian Bull
21	*/
22	public interface ConstraintAdapter {
23
24	/**
25	*
26	* @param object
27	* @param constraint
28	*/
29	public void populateConstraint(Object object, LayoutConstraint constraint);
30
31	}

Added Link Here

(-)src/org/eclipse/zest/core/widgets/InternalNodeLayout.java (+201 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 Mateusz Matela and others. All rights reserved. This
3	* program and the accompanying materials are made available under the terms of
4	* the Eclipse Public License v1.0 which accompanies this distribution, and is
5	* available at http://www.eclipse.org/legal/epl-v10.html
6	*
7	* Contributors:
8	* Mateusz Matela <mateusz.matela@gmail.com> - initial API and implementation
9	*******************************************************************************/
10
11	package org.eclipse.zest.core.widgets;
12
13	import java.util.ArrayList;
14	import java.util.Iterator;
15
16	import org.eclipse.draw2d.geometry.Dimension;
17	import org.eclipse.draw2d.geometry.Point;
18	import org.eclipse.zest.layouts.ConnectionLayout;
19	import org.eclipse.zest.layouts.EntityLayout;
20	import org.eclipse.zest.layouts.NodeLayout;
21	import org.eclipse.zest.layouts.SubgraphLayout;
22	import org.eclipse.zest.layouts.dataStructures.DisplayIndependentDimension;
23	import org.eclipse.zest.layouts.dataStructures.DisplayIndependentPoint;
24
25	class InternalNodeLayout implements NodeLayout {
26	private DisplayIndependentPoint location;
27	private DisplayIndependentDimension size;
28	private boolean minimized = false;
29	private final GraphNode node;
30	private final InternalLayoutContext ownerLayoutContext;
31	private SubgraphLayout subgraph;
32
33	public InternalNodeLayout(GraphNode graphNode) {
34	this.node = graphNode;
35	this.ownerLayoutContext = node.parent.getLayoutContext();
36	}
37
38	public DisplayIndependentPoint getLocation() {
39	if (location == null) {
40	Point location2 = node.getLocation();
41	location = new DisplayIndependentPoint(location2.x + getSize().width / 2, location2.y + size.height / 2);
42	}
43	return new DisplayIndependentPoint(location);
44	}
45
46	public DisplayIndependentDimension getSize() {
47	if (size == null) {
48	Dimension size2 = node.getSize();
49	size = new DisplayIndependentDimension(size2.width, size2.height);
50	}
51	return new DisplayIndependentDimension(size);
52	}
53
54	public SubgraphLayout getSubgraph() {
55	return subgraph;
56	}
57
58	public boolean isMovable() {
59	return true;
60	}
61
62	public boolean isPrunable() {
63	return ownerLayoutContext.isPruningEnabled();
64	}
65
66	public boolean isPruned() {
67	return subgraph != null;
68	}
69
70	public boolean isResizable() {
71	return (node.parent.getAdaptee().getStyle() & ZestStyles.NODES_NO_LAYOUT_RESIZE) == 0;
72	}
73
74	public void prune(SubgraphLayout subgraph) {
75	if (subgraph == this.subgraph) {
76	return;
77	}
78	if (this.subgraph != null) {
79	SubgraphLayout subgraph2 = this.subgraph;
80	this.subgraph = null;
81	subgraph2.removeNodes(new NodeLayout[] { this });
82	}
83	if (subgraph != null) {
84	this.subgraph = subgraph;
85	subgraph.addNodes(new NodeLayout[] { this });
86	}
87	}
88
89	public void setLocation(double x, double y) {
90	location = new DisplayIndependentPoint(x, y);
91	}
92
93	public void setSize(double width, double height) {
94	size = new DisplayIndependentDimension(width, height);
95	}
96
97	public void setMinimized(boolean minimized) {
98	getSize();
99	this.minimized = minimized;
100	}
101
102	public boolean isMinimized() {
103	return minimized;
104	}
105
106	public NodeLayout[] getPredecessingNodes() {
107	ConnectionLayout[] connections = getIncomingConnections();
108	NodeLayout[] result = new NodeLayout[connections.length];
109	for (int i = 0; i < connections.length; i++) {
110	result[i] = connections[i].getSource();
111	if (result[i] == this) {
112	result[i] = connections[i].getTarget();
113	}
114	}
115	return result;
116	}
117
118	public NodeLayout[] getSuccessingNodes() {
119	ConnectionLayout[] connections = getOutgoingConnections();
120	NodeLayout[] result = new NodeLayout[connections.length];
121	for (int i = 0; i < connections.length; i++) {
122	result[i] = connections[i].getTarget();
123	if (result[i] == this) {
124	result[i] = connections[i].getSource();
125	}
126	}
127	return result;
128	}
129
130	public EntityLayout[] getSuccessingEntities() {
131	// TODO Auto-generated method stub
132	return getSuccessingNodes();
133	}
134
135	public EntityLayout[] getPredecessingEntities() {
136	// TODO Auto-generated method stub
137	return getPredecessingNodes();
138	}
139
140	public ConnectionLayout[] getIncomingConnections() {
141	ArrayList result = new ArrayList();
142	for (Iterator iterator = node.getTargetConnections().iterator(); iterator.hasNext();) {
143	GraphConnection connection = (GraphConnection) iterator.next();
144	if (!ownerLayoutContext.isLayoutItemFiltered(connection)) {
145	result.add(connection.getLayout());
146	}
147	}
148	for (Iterator iterator = node.getSourceConnections().iterator(); iterator.hasNext();) {
149	GraphConnection connection = (GraphConnection) iterator.next();
150	if (!connection.isDirected() && !ownerLayoutContext.isLayoutItemFiltered(connection)) {
151	result.add(connection.getLayout());
152	}
153	}
154	return (ConnectionLayout[]) result.toArray(new ConnectionLayout[result.size()]);
155	}
156
157	public ConnectionLayout[] getOutgoingConnections() {
158	ArrayList result = new ArrayList();
159	for (Iterator iterator = node.getSourceConnections().iterator(); iterator.hasNext();) {
160	GraphConnection connection = (GraphConnection) iterator.next();
161	if (!ownerLayoutContext.isLayoutItemFiltered(connection)) {
162	result.add(connection.getLayout());
163	}
164	}
165	for (Iterator iterator = node.getTargetConnections().iterator(); iterator.hasNext();) {
166	GraphConnection connection = (GraphConnection) iterator.next();
167	if (!connection.isDirected() && !ownerLayoutContext.isLayoutItemFiltered(connection)) {
168	result.add(connection.getLayout());
169	}
170	}
171	return (ConnectionLayout[]) result.toArray(new ConnectionLayout[result.size()]);
172	}
173
174	public double getPreferredAspectRatio() {
175	return 0;
176	}
177
178	void applyLayout() {
179	if (minimized) {
180	node.setSize(0, 0);
181	if (location != null) {
182	node.setLocation(location.x, location.y);
183	}
184	} else {
185	if (location != null) {
186	node.setLocation(location.x - getSize().width / 2, location.y - size.height / 2);
187	}
188	if (size != null) {
189	node.setSize(size.width, size.height);
190	}
191	}
192	}
193
194	InternalLayoutContext getOwnerLayoutContext() {
195	return ownerLayoutContext;
196	}
197
198	public String toString() {
199	return node.toString() + "(layout)";
200	}
201	}

Added Link Here

(-)src/org/eclipse/zest/core/widgets/LayoutFilter.java (+35 lines)
1	/*******************************************************************************
2	* Copyright 2005, 2009 CHISEL Group, University of Victoria, Victoria, BC, Canada.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* The Chisel Group, University of Victoria
10	* Mateusz Matela <mateusz.matela@gmail.com> - Adapt Zest to changes in layout - https://bugs.eclipse.org/bugs/show_bug.cgi?id=283179
11	*******************************************************************************/
12	package org.eclipse.zest.core.widgets;
13
14	/**
15	* A filter is used to filter objects. Once implemented, interested
16	* parties can ask this filter whether or not a specific object
17	* is filtered.
18	*
19	* For example, in a visualization tool, only unfiltered objects should
20	* be displayed. Before displaying an object, the display can ask
21	* this filter if the object is filtered.
22	*
23	* @author Casey Best
24	*/
25	public interface LayoutFilter {
26
27	/**
28	* Returns true if the object is filtered, or false if it's not filtered.
29	*
30	* @param item
31	* object to check
32	* @return
33	*/
34	public boolean isObjectFiltered(GraphItem item);
35	}

Added Link Here

(-)src/org/eclipse/zest/core/widgets/NodeContainerAdapter.java (+214 lines)
1	/*******************************************************************************
2	* Copyright (c) 2009 Mateusz Matela and others. All rights reserved. This
3	* program and the accompanying materials are made available under the terms of
4	* the Eclipse Public License v1.0 which accompanies this distribution, and is
5	* available at http://www.eclipse.org/legal/epl-v10.html
6	*
7	* Contributors:
8	* Mateusz Matela <mateusz.matela@gmail.com> - initial API and implementation
9	*******************************************************************************/
10
11	package org.eclipse.zest.core.widgets;
12
13	import java.util.ArrayList;
14	import java.util.HashMap;
15	import java.util.Iterator;
16	import java.util.List;
17
18	import org.eclipse.draw2d.IFigure;
19	import org.eclipse.draw2d.geometry.Dimension;
20	import org.eclipse.swt.widgets.Widget;
21	import org.eclipse.zest.layouts.dataStructures.DisplayIndependentRectangle;
22
23	/**
24	* This adapter unifies API of {@link Graph} and {@link GraphContainer} and
25	* is used everywhere objects of both these classes can be expected.
26	*
27	* It's introduced in order to prevent some methods from change to public with
28	* common interface.
29	*/
30	abstract class NodeContainerAdapter {
31	private static class GraphAdapter extends NodeContainerAdapter {
32	private Graph graph;
33
34	private GraphAdapter(Graph graph) {
35	graph.getStyle();
36	this.graph = graph;
37	}
38
39	public Widget getAdaptee() {
40	return graph;
41	}
42
43	public Graph getGraph() {
44	return graph;
45	}
46
47	public List getNodes() {
48	return graph.getNodes();
49	}
50
51	public List getConnections() {
52	return filterConnections(graph.getConnections());
53	}
54
55	public void addNode(GraphNode graphNode) {
56	graph.addNode(graphNode);
57	}
58
59	public void addFigure(IFigure figure) {
60	graph.addFigure(figure);
61	}
62
63	public void highlightNode(GraphNode graphNode) {
64	graph.highlightNode(graphNode);
65	}
66
67	public void unhighlightNode(GraphNode graphNode) {
68	graph.highlightNode(graphNode);
69	}
70
71	public int getItemType() {
72	return GraphItem.GRAPH;
73	}
74
75	public DisplayIndependentRectangle getLayoutBounds() {
76	Dimension preferredSize = graph.getPreferredSize();
77	return new DisplayIndependentRectangle(0, 0, preferredSize.width, preferredSize.height);
78	}
79
80	public InternalLayoutContext getLayoutContext() {
81	return graph.getLayoutContext();
82	}
83	}
84
85	private static class GraphContainerAdapter extends NodeContainerAdapter {
86	private GraphContainer container;
87
88	private GraphContainerAdapter(GraphContainer container) {
89	this.container = container;
90	}
91
92	public Widget getAdaptee() {
93	return container;
94	}
95
96	public Graph getGraph() {
97	return container.getGraph();
98	}
99
100	public List getNodes() {
101	return container.getNodes();
102	}
103
104	public List getConnections() {
105	return filterConnections(container.getGraph().getConnections());
106	}
107
108	public void addNode(GraphNode graphNode) {
109	container.addNode(graphNode);
110	}
111
112	public void addFigure(IFigure figure) {
113	container.addFigure(figure);
114	}
115
116	public void highlightNode(GraphNode graphNode) {
117	/* do nothing */
118	}
119
120	public void unhighlightNode(GraphNode graphNode) {
121	/* do nothing */
122	}
123
124	public int getItemType() {
125	return GraphItem.CONTAINER;
126	}
127
128	public DisplayIndependentRectangle getLayoutBounds() {
129	return container.getLayoutBounds();
130	}
131
132	public InternalLayoutContext getLayoutContext() {
133	return container.getLayoutContext();
134	}
135	}
136
137	private static HashMap adaptersMap = new HashMap();
138
139	static NodeContainerAdapter get(Graph graph) {
140	NodeContainerAdapter adapter = (NodeContainerAdapter) adaptersMap.get(graph);
141	if (adapter != null) {
142	return adapter;
143	}
144
145	adapter = new GraphAdapter(graph);
146	adaptersMap.put(graph, adapter);
147	return adapter;
148	}
149
150	static NodeContainerAdapter get(GraphContainer container) {
151	NodeContainerAdapter adapter = (NodeContainerAdapter) adaptersMap.get(container);
152	if (adapter != null) {
153	return adapter;
154	}
155
156	adapter = new GraphContainerAdapter(container);
157	adaptersMap.put(container, adapter);
158	return adapter;
159	}
160
161	public abstract Widget getAdaptee();
162
163	public abstract Graph getGraph();
164
165	public abstract List getNodes();
166
167	/**
168	* Returns list of connections laying inside this container. Only
169	* connections which both source and target nodes lay directly in this
170	* container are returned.
171	*
172	* @return
173	*/
174	public abstract List getConnections();
175
176	public abstract void addNode(GraphNode graphNode);
177
178	/**
179	* Adds a custom figure to be displayed on top of nodes. Can be used to add
180	* subgraph figures.
181	*
182	* @param figure
183	*/
184	public abstract void addFigure(IFigure figure);
185
186	public abstract void highlightNode(GraphNode graphNode);
187
188	public abstract void unhighlightNode(GraphNode graphNode);
189
190	public abstract int getItemType();
191
192	public abstract DisplayIndependentRectangle getLayoutBounds();
193
194	public abstract InternalLayoutContext getLayoutContext();
195
196	/**
197	* Takes a list of connections and returns only those which source and
198	* target nodes lay directly in this container.
199	*
200	* @param connections
201	* list of GraphConnection to filter
202	* @return filtered list
203	*/
204	protected List filterConnections(List connections) {
205	List result = new ArrayList();
206	for (Iterator iterator = connections.iterator(); iterator.hasNext();) {
207	GraphConnection connection = (GraphConnection) iterator.next();
208	if (connection.getSource().getParent() == this && connection.getDestination().getParent() == this) {
209	result.add(connection);
210	}
211	}
212	return result;
213	}
214	}