source: trunk/src/org/expeditee/agents/GraphFramesetLinks.java@ 1415

/**
 *    GraphFramesetLinks.java
 *    Copyright (C) 2010 New Zealand Digital Library, http://expeditee.org
 *
 *    This program is free software: you can redistribute it and/or modify
 *    it under the terms of the GNU General Public License as published by
 *    the Free Software Foundation, either version 3 of the License, or
 *    (at your option) any later version.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU General Public License for more details.
 *
 *    You should have received a copy of the GNU General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

package org.expeditee.agents;

import java.util.List;

import org.expeditee.actions.Misc;
import org.expeditee.core.Colour;
import org.expeditee.core.Font;
import org.expeditee.gio.gesture.StandardGestureActions;
import org.expeditee.gui.DisplayController;
import org.expeditee.gui.Frame;
import org.expeditee.gui.FrameIO;
import org.expeditee.gui.FrameUtils;
import org.expeditee.items.Item;
import org.expeditee.items.Line;
import org.expeditee.items.Text;

import com.mxgraph.layout.mxCircleLayout;
import com.mxgraph.layout.mxCompactTreeLayout;
import com.mxgraph.layout.mxFastOrganicLayout;
import com.mxgraph.layout.mxGraphLayout;
import com.mxgraph.layout.mxOrganicLayout;
import com.mxgraph.layout.hierarchical.mxHierarchicalLayout;
import com.mxgraph.model.mxCell;
import com.mxgraph.model.mxGeometry;
import com.mxgraph.model.mxGraphModel;
import com.mxgraph.view.mxGraph;

/**
 * Generates a graph/visualization of the current frameset in terms of how frames are linked to each other
 * The layout type used (tree, organic, circle, hierarchical, or the default, fastorganic) can be specified 
 * when calling the action (e.g. 'GraphFramesetLinks circle').
 * <br >
 * Uses JGraphX to compute the graph layout
 * @author ngw8
 *
 */
public class GraphFramesetLinks extends DefaultAgent {
        
        private String layoutMethod;
        
        public GraphFramesetLinks(String layoutMethod) {
                this.layoutMethod = layoutMethod;
        }
        
        public GraphFramesetLinks() {
                this.layoutMethod = "";
        }

        @Override
        protected Frame process(Frame frame) {
                String toProcessFramesetName = frame.getFramesetName();

                Frame toProccess = FrameUtils.getFrame(toProcessFramesetName + 0);

                Frame resultsFrame;
                
                String resultsFramesetName = "LinksGraphResults";

                Colour vertColor = Colour.FromRGB255(51,145,148);
                Colour unlinkedVertColor = Colour.FromRGB255(251,107,65);
                Colour outgoingVertColor = Colour.FromRGB255(246,216,107);
                Colour lineColor = Colour.FromRGBA255(0,0,0, 20);

                try {
                        // Creating frameset that is used to hold any generated link graphs
                        FrameIO.CreateNewFrameset(resultsFramesetName);
                } catch (Exception e2) {
                        // frameset already exists
                }

                resultsFrame = FrameIO.CreateFrame(resultsFramesetName, toProcessFramesetName, null);
                resultsFrame.removeAllItems(resultsFrame.getAllItems());
                
                mxGraph graph = new mxGraph();
                mxGraphModel model = (mxGraphModel) graph.getModel();
                mxGraphLayout layout;

                // Deciding which layout method to use
                if(this.layoutMethod.equalsIgnoreCase("organic")) {
                        layout = new mxOrganicLayout(graph);
                } else if (this.layoutMethod.equalsIgnoreCase("circle")) {
                        layout = new mxCircleLayout(graph);
                } else if (this.layoutMethod.equalsIgnoreCase("tree")) {
                        layout = new mxCompactTreeLayout(graph);
                        ((mxCompactTreeLayout)layout).setLevelDistance(30);
                } else if(this.layoutMethod.equalsIgnoreCase("hierarchical")) {
                        layout = new mxHierarchicalLayout(graph);
                } else {
                        layout = new mxFastOrganicLayout(graph);
                }
                
                model.beginUpdate();

                try {
                        while ((toProccess = FrameIO.LoadNext(toProccess)) != null) {

                                Object sourceVert = model.getCell(toProccess.getName());

                                if (sourceVert == null) {
                                        sourceVert = graph.insertVertex(graph.getDefaultParent(), toProccess.getName(), toProccess.getName(), 0, 0, 10, 10);
                                }

                                List<Item> items = toProccess.getSortedItems();

                                for (Item item : items) {
                                        if (item.getLink() != null) {
                                                
                                                Object destinationVert = model.getCell(item.getAbsoluteLink());

                                                if (destinationVert == null) {
                                                        destinationVert = graph.insertVertex(graph.getDefaultParent(), item.getAbsoluteLink(), item.getAbsoluteLink(), 0, 0, 10, 10);
                                                }
                                                
                                                // Scaling the vertex based on the number of incoming links
                                                mxGeometry destGeo = ((mxCell)(destinationVert)).getGeometry();
                                                destGeo.setHeight(destGeo.getHeight() + 1);
                                                destGeo.setWidth(destGeo.getHeight());

                                                graph.insertEdge(graph.getDefaultParent(), null, null, sourceVert, destinationVert);
                                        }
                                }
                        }

                        layout.execute(graph.getDefaultParent());

                } finally {
                        graph.getModel().endUpdate();
                }

                Object[] verts = graph.getChildVertices(graph.getDefaultParent());

                for (Object v : verts) {
                        mxGeometry geo = graph.getCellGeometry(v);

                        Item circleCenter = resultsFrame.addDot((int) geo.getCenterX(),(int) geo.getCenterY());
                        
                        Text circleEdge = (Text) resultsFrame.addText((int) geo.getX(), (int) geo.getCenterY(), "@c", null, ((mxCell) v).getId());
                        
                        Line circle = new Line(circleCenter, circleEdge, resultsFrame.getNextItemID());

                        circleCenter.setLink(((mxCell) v).getId());
                        circleCenter.setTooltip("text: " + ((mxCell) v).getId());
                        circleCenter.setTooltip("text: In: " + mxGraphModel.getDirectedEdgeCount(model, v, false));
                        circleCenter.setTooltip("text: Out: " + mxGraphModel.getDirectedEdgeCount(model, v, true));
                        
                        circleCenter.setThickness(0);
                        circleCenter.setFillColor(vertColor);

                        // If the vert is not in the current frameset, style it differently to denote this
                        if (!((String) model.getValue(v)).replaceAll("\\d+$", "").equals(toProcessFramesetName)) {
                                circleCenter.setFillColor(outgoingVertColor);
                        }
                        
                        // If there are no incoming edges (i.e. no frames link to the frame the vert represents), style it differently to denote this
                        if (mxGraphModel.getDirectedEdgeCount(model, v, false) <= 0) {
                                circleCenter.setFillColor(unlinkedVertColor);
                        }
                        
                        resultsFrame.addItem(circle);
                }

                Object[] edges = graph.getChildEdges(graph.getDefaultParent());

                for (Object e : edges) {
                        mxGeometry sourceGeo = graph.getCellGeometry(((mxCell) e).getTerminal(true));
                        mxGeometry destGeo = graph.getCellGeometry(((mxCell) e).getTerminal(false));

                        // create the endpoints of the edge/line
                        Item lineEnd = resultsFrame.createDot();
                        Item lineStart = resultsFrame.createDot();

                        lineStart.setPosition((int) sourceGeo.getCenterX(), (int) sourceGeo.getCenterY());
                        lineEnd.setPosition((int) destGeo.getCenterX(), (int) destGeo.getCenterY());

                        lineStart.anchor();
                        lineEnd.anchor();

                        lineEnd.setArrowheadLength(10);
                        
                        // create the edge/line
                        Line line = new Line(lineStart, lineEnd, resultsFrame.getNextItemID());
                        
                        line.setColor(lineColor);
                        line.setThickness(1);
                        
                        // The edge/line currently has its endpoints at the vert centers, which doesn't look nice, so this shifts them out to the edge of the verts/circles
                        float ratio = (float) (destGeo.getWidth() / (2 * line.getLength()));
                        int x3 = Math.round(ratio* ((line.getStartItem().getX() - line.getEndItem().getX())));
                        int y3 = Math.round(ratio * ((line.getStartItem().getY() - line.getEndItem().getY())));

                        line.getEndItem().setX(line.getEndItem().getX() + x3);
                        line.getEndItem().setY(line.getEndItem().getY() + y3);
                        
                        // Have to redo the calculation for the source vert, as it could have a different size
                        ratio = (float) (sourceGeo.getWidth() / (2 * line.getLength()));
                        x3 = Math.round(ratio* ((line.getEndItem().getX() - line.getStartItem().getX())));
                        y3 = Math.round(ratio * ((line.getEndItem().getY() - line.getStartItem().getY())));

                        line.getStartItem().setX(line.getStartItem().getX() + x3);
                        line.getStartItem().setY(line.getStartItem().getY() + y3);

                        resultsFrame.addItem(line);
                }
                
                Font keyFont = new Font("SansSerif");
                keyFont.setSize(14);
                
                Text keyLink = resultsFrame.addText(0, 0, "\u2192 = Link", null);
                Text keyFrame = resultsFrame.addText(0, 0, "\u25CF = Frame", null);
                Text keyFrameUnlinked = resultsFrame.addText(0, 0, "\u25CF = Frame with no incoming links", null);
                Text keyFrameOutgoing = resultsFrame.addText(0, 0, "\u25CF = Frame in a different frameset", null);
                
                keyLink.setFont(keyFont.clone());
                keyLink.setColor(Colour.DARK_GREY);
                
                keyFrame.setFont(keyFont.clone());
                keyFrame.setColor(vertColor);
                
                keyFrameUnlinked.setFont(keyFont.clone());
                keyFrameUnlinked.setColor(unlinkedVertColor);
                
                keyFrameOutgoing.setFont(keyFont.clone());
                keyFrameOutgoing.setColor(outgoingVertColor);
                
                keyFrameOutgoing.setAnchorBottom(10);
                keyFrameUnlinked.setAnchorBottom(30);
                keyFrame.setAnchorBottom(50);
                keyLink.setAnchorBottom(70);
                
                keyFrameOutgoing.setAnchorLeft(10);
                keyFrameUnlinked.setAnchorLeft(10);
                keyFrame.setAnchorLeft(10);
                keyLink.setAnchorLeft(10);

                // Moving to the area of the frame that contains the graph
                Misc.pan(resultsFrame, - (int) graph.getGraphBounds().getX(), - (int) graph.getGraphBounds().getY());

                FrameIO.SaveFrame(resultsFrame);

                Text link = new Text(toProcessFramesetName + " graph");
                link.setLink(resultsFrame.getName());
                link.setPosition(DisplayController.getMousePosition());
                StandardGestureActions.pickup(link);
                return null;
        }
}