/*******************************************************************************
* Copyright (c) 2004, 2006 Sybase, Inc. 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:
* Sybase, Inc. - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsf.facesconfig.ui.pageflow.layout;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import org.eclipse.draw2d.geometry.Insets;
import org.eclipse.draw2d.geometry.Rectangle;
import org.eclipse.draw2d.graph.DirectedGraph;
import org.eclipse.draw2d.graph.DirectedGraphLayout;
import org.eclipse.draw2d.graph.Edge;
import org.eclipse.draw2d.graph.EdgeList;
import org.eclipse.draw2d.graph.Node;
import org.eclipse.draw2d.graph.NodeList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.jst.jsf.facesconfig.ui.pageflow.model.Pageflow;
import org.eclipse.jst.jsf.facesconfig.ui.pageflow.model.PageflowFactory;
import org.eclipse.jst.jsf.facesconfig.ui.pageflow.model.PageflowLink;
import org.eclipse.jst.jsf.facesconfig.ui.pageflow.model.PageflowLinkBendpoint;
import org.eclipse.jst.jsf.facesconfig.ui.pageflow.model.PageflowNode;
import org.eclipse.jst.jsf.facesconfig.ui.pageflow.model.PageflowPage;
import org.eclipse.jst.jsf.facesconfig.ui.pageflow.util.PageflowModelManager;
/**
* This class is a singleton adpater to create the directed graph for the
* specified pageflow model or update the location information of pageflow model
* according to directed graph layout algorithms.
*
* @author Xiao-guang Zhang
*/
public class PageflowLayoutManager {
/** node's default size */
private static final int NODE_DEFAULT_WIDTH = 50;
private static final int NODE_DEFAULT_HEIGHT = 50;
/**
* the margin of the top and left , and margin between each connnected
* directed graph.
*/
private static final int X_SPACE = 50;
private static final int Y_SPACE = 50;
/** node's default padding */
private static final int DEFAULT_PADDING = 30;
private static PageflowLayoutManager manager;
private Map copiedLinks = null;
/**
* constructor of PageflowDirectedGraphAdapter
*
*/
private PageflowLayoutManager() {
// no external instantiation
}
/**
* return the singleton instance of PageflowDirectedGraphAdapter
*
* @return - the singleton instance of PageflowDirectedGraphAdapter
*/
static public PageflowLayoutManager getInstance() {
if (manager == null) {
manager = new PageflowLayoutManager();
}
return manager;
}
/**
* layout pageflow using directed graph layout algorithms
*
* @param pageflow -
* pageflow model
*/
public void layoutPageflow(Pageflow pageflow) {
List selfLoopLinks = removeSelfLoopLinks(pageflow);
List lstGraph = createGraphs(pageflow);
for (Iterator iter = lstGraph.iterator(); iter.hasNext();) {
DirectedGraph graph = (DirectedGraph) iter.next();
new DirectedGraphLayout().visit(graph);// .visit(graph);
}
updatePageflow(lstGraph);
if (selfLoopLinks != null) {
addSelfLoopLinks(pageflow, selfLoopLinks);
}
}
/**
* remove the self loop links from pageflow, because the layout algorithm
* does not allow it.
*
* @param pageflow
* @return
*/
private List removeSelfLoopLinks(Pageflow pageflow) {
List selfLoopLinks = new ArrayList();
if (pageflow.getLinks() != null) {
for (Iterator iter = pageflow.getLinks().iterator(); iter.hasNext();) {
PageflowLink link = (PageflowLink) iter.next();
if (link.getSource() == link.getTarget()) {
iter.remove();
link.getBendPoints().clear();
selfLoopLinks.add(link);
}
}
}
return selfLoopLinks;
}
/**
* add back the self loop links with updated bendpoints.
*
* @param pageflow
* @param selfLoopLinks
*/
private void addSelfLoopLinks(Pageflow pageflow, List selfLoopLinks) {
if (pageflow.getLinks() != null && selfLoopLinks != null
&& selfLoopLinks.size() > 0) {
EList links = pageflow.getLinks();
for (Iterator iter = selfLoopLinks.iterator(); iter.hasNext();) {
PageflowLink link = (PageflowLink) iter.next();
updateSelfLoopLink(link);
links.add(link);
}
}
}
/**
* Update the bendpoints of the self loop link Follow the following style:
*
* LeftTop-Top | | Left----Node
*
* @param selfLoopLink
*/
public static void updateSelfLoopLink(PageflowLink selfLoopLink) {
PageflowNode sourceNode = selfLoopLink.getSource();
Rectangle rectNode = getPageflowNodeBounds(sourceNode);
EList outLinks = sourceNode.getOutlinks();
if (outLinks != null && outLinks.size() > 0) {
for (Iterator iter = outLinks.iterator(); iter.hasNext();) {
PageflowLink anotherSelfLoopLink = (PageflowLink) iter.next();
if (anotherSelfLoopLink != selfLoopLink
&& anotherSelfLoopLink.getTarget() == sourceNode) {
rectNode = getFitnessRectangle(rectNode,
anotherSelfLoopLink);
}
}
}
PageflowFactory factory = PageflowModelManager.getFactory();
PageflowLinkBendpoint bpTop = factory.createPFLinkBendpoint();
PageflowLinkBendpoint bpLeftTop = factory.createPFLinkBendpoint();
PageflowLinkBendpoint bpLeft = factory.createPFLinkBendpoint();
bpTop.setD1Height(-rectNode.height);
bpTop.setD2Height(-rectNode.height);
bpLeftTop.setD1Width(-rectNode.width);
bpLeftTop.setD1Height(-rectNode.height);
bpLeftTop.setD2Width(-rectNode.width);
bpLeftTop.setD2Height(-rectNode.height);
bpLeft.setD1Width(-rectNode.width);
bpLeft.setD2Width(-rectNode.width);
selfLoopLink.getBendPoints().add(bpTop);
selfLoopLink.getBendPoints().add(bpLeftTop);
selfLoopLink.getBendPoints().add(bpLeft);
}
/**
* Calculate the fitness rectangle without conflict with the existing self
* loop's rectangle.
*
* @param rectDefault
* @param anotherSelfLoopLink
*/
private static Rectangle getFitnessRectangle(Rectangle rectDefault,
PageflowLink anotherSelfLoopLink) {
EList bendPoints = anotherSelfLoopLink.getBendPoints();
if (bendPoints != null && bendPoints.size() > 0) {
for (Iterator iterBendPoint = bendPoints.iterator(); iterBendPoint
.hasNext();) {
PageflowLinkBendpoint bendPoint = (PageflowLinkBendpoint) iterBendPoint
.next();
if (bendPoint.getD1Width() == -rectDefault.width
&& bendPoint.getD1Height() == -rectDefault.height) {
rectDefault = new Rectangle(0, 0, rectDefault.width
+ DEFAULT_PADDING, rectDefault.height
+ DEFAULT_PADDING);
break;
}
}
}
return rectDefault;
}
/**
* get the pageflow node's bounds, the orginal point is (0,0)
*
* @param pfNode
* @return
*/
private static Rectangle getPageflowNodeBounds(PageflowNode pfNode) {
return new Rectangle(0, 0, 64, 36);
}
/**
* get the pageflow node's border rectangle
*
* @param pfNode
* @return
*/
private static Rectangle getPageflowNodeRectangle(PageflowNode pfNode) {
Rectangle rectNode = null;
Rectangle bounds = getPageflowNodeBounds(pfNode);
rectNode = new Rectangle(pfNode.getX(), pfNode.getY(), bounds.width,
bounds.height);
return rectNode;
}
/**
* create the connected subgraphs for the pageflow model, because there
* maybe more than one connected graph in one pageflow definition.
*
* @param pageflow -
* Pageflow model
* @return - the connected subgraphs
*/
private List createGraphs(Pageflow pageflow) {
/** the connected subgraphs */
List lstGraph = null;
if (pageflow != null) {
// Graph is not connected totally.
DirectedGraph graph = null;
HashMap nodesMap = new HashMap();
NodeList nodes = new NodeList();
EdgeList edges = new EdgeList();
// get all nodes in the pageflow
List pfNodes = pageflow.getNodes();
if (pfNodes != null) {
for (Iterator iter = pfNodes.iterator(); iter.hasNext();) {
PageflowNode pfNode = (PageflowNode) iter.next();
Node node = new Node(pfNode);
Rectangle rectNode = null;
rectNode = getPageflowNodeBounds(pfNode);
if (rectNode != null) {
node.width = rectNode.width * 2;
node.height = rectNode.height * 2;
node.setPadding(new Insets(node.height, node.width,
node.height, node.width));
} else {
node.width = NODE_DEFAULT_WIDTH;
node.height = NODE_DEFAULT_HEIGHT;
node.setPadding(new Insets(DEFAULT_PADDING));
}
nodesMap.put(pfNode, node);
nodes.add(node);
}
}
// get all edges in the pageflow
List pfLinks = pageflow.getLinks();
for (Iterator iter = pfLinks.iterator(); iter.hasNext();) {
PageflowLink link = (PageflowLink) iter.next();
PageflowNode source = link.getSource();
PageflowNode target = link.getTarget();
Node sourceNode = (Node) nodesMap.get(source);
Node targetNode = (Node) nodesMap.get(target);
if (sourceNode != null && targetNode != null) {
Edge edge = new Edge(sourceNode, targetNode);
edges.add(edge);
}
}
graph = new DirectedGraph();
graph.nodes = nodes;
graph.edges = edges;
// get the connected subgraphs.
lstGraph = new ArrayList();
lstGraph.add(graph);// ..getConnectedSubGraphs();
}
return lstGraph;
}
/**
* update the pageflow according to layout results which are stored in the
* connected subgraphs
*
* @param lstGraph -
* connected subgraphs
*
*/
private void updatePageflow(List lstGraph) {
// y coordiantion of the subgraph's start point
int topSubGraph = 0;
for (Iterator iter = lstGraph.iterator(); iter.hasNext();) {
// sub graph's bottom
int bottomSubGraph = 0;
DirectedGraph graph = (DirectedGraph) iter.next();
for (int i = 0; i < graph.nodes.size(); i++) {
Node node = graph.nodes.getNode(i);
if (!(node.data instanceof PageflowNode)) {
continue;
}
PageflowNode pfNode = (PageflowNode) node.data;
pfNode.setX(X_SPACE + node.y);
pfNode.setY(Y_SPACE + node.x + topSubGraph);
if ((Y_SPACE + node.x + topSubGraph) > bottomSubGraph) {
bottomSubGraph = Y_SPACE + node.x + topSubGraph;
}
}
topSubGraph = bottomSubGraph + Y_SPACE;
}
}
/**
* update new pageflow's layout using the existing one.
* @param newPageflow
* @param oldPageflow
*/
public void updatePageflowLayout(Pageflow newPageflow, Pageflow oldPageflow) {
List notUpdatedNodes = new ArrayList();
copiedLinks = new HashMap();
if (oldPageflow.getNodes().size() > 0) {
for (Iterator iter = newPageflow.getNodes().iterator(); iter
.hasNext();) {
PageflowNode newNode = (PageflowNode) iter.next();
if (!updatePageflowNode(newNode, oldPageflow)) {
notUpdatedNodes.add(newNode);
}
}
} else {
notUpdatedNodes.addAll(newPageflow.getNodes());
}
if (oldPageflow.getLinks().size() > 0) {
for (Iterator iter = newPageflow.getLinks().iterator(); iter
.hasNext();) {
PageflowLink newLink = (PageflowLink) iter.next();
updatePFLink(newLink, oldPageflow);
}
}
// if there are still some nodes which are not updated,
// they should be check whether there are some layout conflict.
if (notUpdatedNodes.size() > 0) {
resolveConflict(newPageflow, notUpdatedNodes);
}
}
/**
* Update pageflow node using the same node
*
* @param object
* @return - the old pageflow node.
*/
private boolean updatePageflowNode(PageflowNode newNode,
Pageflow oldPageflow) {
for (Iterator iter = oldPageflow.getNodes().iterator(); iter.hasNext();) {
PageflowNode oldNode = (PageflowNode) iter.next();
if (oldNode instanceof PageflowPage
&& newNode instanceof PageflowPage) {
if (((PageflowPage) oldNode).getPath().trim().equals(
((PageflowPage) newNode).getPath().trim())) {
updatePageflowNode(newNode, oldNode);
return true;
}
}
}
return false;
}
/**
* Update pageflow node using the same node
*
* @param object
*/
private void updatePageflowNode(PageflowNode newNode, PageflowNode node) {
newNode.setX(node.getX());
newNode.setY(node.getY());
}
/**
* If there are conflict for the nodes, it will resolve it.
*
* @param newPageflow
* @param notUpdatedNodes
*/
private void resolveConflict(Pageflow newPageflow, List notUpdatedNodes) {
for (Iterator iter = notUpdatedNodes.iterator(); iter.hasNext();) {
resolveConflict(newPageflow, (PageflowNode) iter.next());
}
}
/**
* Resolve the layout conflict
*
* @param newPageflow
* @param node
*/
private void resolveConflict(Pageflow newPageflow, PageflowNode node) {
Rectangle nodeRect = getPageflowNodeRectangle(node);
boolean bModified = false;
for (int i = 0, size = newPageflow.getNodes().size(); i < size; i++) {
PageflowNode fixedNode = (PageflowNode) newPageflow.getNodes().get(
i);
if (node == fixedNode) {
continue;
}
Rectangle fixedNodeRect = getPageflowNodeRectangle(fixedNode);
if (fixedNodeRect.intersects(nodeRect)) {
nodeRect.x += fixedNodeRect.width + X_SPACE;
nodeRect.y += fixedNodeRect.height + Y_SPACE;
bModified = true;
}
}
if (bModified) {
node.setX(nodeRect.x);
node.setY(nodeRect.y);
}
}
/**
* Update the link using the same link in the old pageflow
*
* @param newLink
* @param oldPageflow
*/
private void updatePFLink(PageflowLink newLink, Pageflow oldPageflow) {
for (Iterator iter = oldPageflow.getLinks().iterator(); iter.hasNext();) {
PageflowLink oldLink = (PageflowLink) iter.next();
if (copiedLinks.get(oldLink) != null) {
continue;
}
if (isSameLink(newLink, oldLink)) {
updatePFLink(newLink, oldLink);
break;
}
}
}
/**
* Check whether this two links in differnet pageflow are same or not.
*
* @param newLink
* @param oldLink
* @return
*/
private boolean isSameLink(PageflowLink newLink, PageflowLink oldLink) {
PageflowNode newSource = newLink.getSource();
PageflowNode newTarget = newLink.getTarget();
PageflowNode oldSource = oldLink.getSource();
PageflowNode oldTarget = oldLink.getTarget();
// Page-Page
if (newSource instanceof PageflowPage
&& oldSource instanceof PageflowPage
&& newTarget instanceof PageflowPage
&& oldTarget instanceof PageflowPage) {
if (((PageflowPage) newSource).getPath().trim().equalsIgnoreCase(
((PageflowPage) oldSource).getPath().trim())
&& ((PageflowPage) newTarget)
.getPath()
.trim()
.equalsIgnoreCase(
((PageflowPage) oldTarget).getPath().trim())) {
if ((newLink.getOutcome() == null && oldLink.getOutcome() == null)
|| (newLink.getOutcome() != null
&& oldLink.getOutcome() != null && newLink
.getOutcome().trim().equals(
oldLink.getOutcome().trim()))) {
return true;
}
}
}
return false;
}
/**
* Update the link using the same link
*
* @param nodesMap
* @param object
* @return
*/
private PageflowLink updatePFLink(PageflowLink newLink, PageflowLink link) {
PageflowFactory factory = PageflowModelManager.getFactory();
newLink.getBendPoints().clear();
for (Iterator iter = link.getBendPoints().iterator(); iter.hasNext();) {
PageflowLinkBendpoint bendPoint = (PageflowLinkBendpoint) iter
.next();
PageflowLinkBendpoint newBendPoint = factory
.createPFLinkBendpoint();
newBendPoint.setD1Height(bendPoint.getD1Height());
newBendPoint.setD1Width(bendPoint.getD1Width());
newBendPoint.setD2Height(bendPoint.getD2Height());
newBendPoint.setD2Width(bendPoint.getD2Width());
newLink.getBendPoints().add(newBendPoint);
}
copiedLinks.put(link, link);
return newLink;
}
}