springlayoutstrategy.java

JPowerGraph is a Java library for creating directed graphs for SWT. It supports graph movement, sele

                //If max motion<0.2, damp away
                //If by the time the damper has ticked down to 0.9, maxMotion is still>1, damp away
                //We never want the damper to be negative though
                if ((m_maxMotion<0.2 || (m_maxMotion>1 && m_damper<0.9)) && m_damper > 0.01)
                    m_damper-=0.01;
                //If we've slowed down significanly, damp more aggresively (then the line two below)
                else if (m_maxMotion<0.4 && m_damper > 0.003)
                    m_damper-=0.003;
                //If max motion is pretty high, and we just started damping, then only damp slightly
                else if(m_damper>0.0001)
                    m_damper -=0.0001;
            }
        }
        if(m_maxMotion<0.001 && m_damping)
            m_damper=0;
    }

    /**
     * The abstract list node.
     */
    protected static class ListNode {
        public ListNode m_next;
        public ListNode m_previous;
        public ListOfNodes m_list;
    }

    /**
     * The list.
     */
    protected static class ListOfNodes {
        public ListNode m_head;
        public ListNode m_tail;
        public int m_size;

        public void add(ListNode node) {
            if (m_head==null) {
                m_head=node;
                m_tail=node;
                node.m_previous=node.m_next=null;
            }
            else {
                m_tail.m_next=node;
                node.m_previous=m_tail;
                node.m_next=null;
                m_tail=node;
            }
            node.m_list=this;
        }
        public void remove(ListNode node) {
            if (m_head==node)
                m_head=node.m_next;
            else
                node.m_previous.m_next=node.m_next;
            if (m_tail==node)
                m_tail=node.m_previous;
            else
                node.m_next.m_previous=node.m_previous;
            node.m_next=node.m_previous=null;
            node.m_list=null;
        }
        public void clear() {
            m_head=m_tail=null;
            m_size=0;
        }
        public void mergeWith(ListOfNodes other) {
            if (m_tail==null) {
                m_head=other.m_head;
                m_tail=other.m_head;
            }
            else if (other.m_head!=null) {
                m_tail.m_next=other.m_head;
                other.m_head.m_previous=m_tail;
                m_tail=other.m_tail;
            }
            ListNode pointer=other.m_head;
            while (pointer!=null) {
                pointer.m_list=this;
                pointer=pointer.m_next;
            }
            m_size+=other.m_size;
            other.m_head=other.m_tail=null;
            other.m_size=0;
        }
    }

    /**
     * Contains information about the node movement.
     */
    protected static class NodeMovement extends ListNode {
        public Node m_node;
        public double m_dx=0.0;
        public double m_dy=0.0;
        public boolean m_justChanged=false;
        public long m_timeWhenNodeBecomesNormal;

        public NodeMovement(Node node) {
            m_node=node;
        }
        public SubGraph getSubGraph() {
            return ((SubGraphList)m_list).m_subGraph;
        }
    }

    /**
     * Contains information about the subgraphs in the overall graph.
     */
    protected class GraphManager extends ListOfNodes {
        /** The node movement objects indexed by the node. */
        protected Map m_nodeMovement;

        public GraphManager() {
            m_nodeMovement=new HashMap();
        }
        public SubGraph getFirstSubGraph() {
            return (SubGraph)m_head;
        }
        public NodeMovement getNodeMovement(Node node) {
            return (NodeMovement)m_nodeMovement.get(node);
        }
        public void nodeChanged(Node node) {
            NodeMovement nodeMovement=getNodeMovement(node);
            if (nodeMovement!=null) {
                nodeMovement.m_justChanged=true;
                nodeMovement.m_timeWhenNodeBecomesNormal=System.currentTimeMillis()+TIME_NODE_REMAINS_CHANGED;
            }
        }
        public void addNode(Node node) {
            if (!m_nodeMovement.containsKey(node)) {
                NodeMovement nodeMovement=new NodeMovement(node);
                m_nodeMovement.put(node,nodeMovement);
                add(new SubGraph(nodeMovement));
            }
            nodeChanged(node);
        }
        public void addEdge(Edge edge) {
            NodeMovement nodeMovement1=getNodeMovement(edge.getFrom());
            NodeMovement nodeMovement2=getNodeMovement(edge.getTo());
            if (nodeMovement1.getSubGraph()!=nodeMovement2.getSubGraph())
                mergeSubGraphs(nodeMovement1.getSubGraph(),nodeMovement2.getSubGraph());
        }
        public void graphContentsChanged() {
            m_nodeMovement.clear();
            clear();
            Iterator nodes=m_graph.getNodes().iterator();
            while (nodes.hasNext()) {
                Node node=(Node)nodes.next();
                addNode(node);
            }
            Iterator edges=m_graph.getEdges().iterator();
            while (edges.hasNext()) {
                Edge edge=(Edge)edges.next();
                addEdge(edge);
            }
        }
        public void elementsAdded(Collection nodes,Collection edges) {
            if (nodes!=null) {
                Iterator iterator=nodes.iterator();
                while (iterator.hasNext()) {
                    Node node=(Node)iterator.next();
                    addNode(node);
                }
            }
            if (edges!=null) {
                Iterator iterator=edges.iterator();
                while (iterator.hasNext()) {
                    Edge edge=(Edge)iterator.next();
                    addEdge(edge);
                }
            }
        }
        public void elementsRemoved(Collection nodes,Collection edges) {
            if (nodes!=null) {
                Iterator iterator=nodes.iterator();
                while (iterator.hasNext()) {
                    Node node=(Node)iterator.next();
                    m_nodeMovement.remove(node);
                }
            }
            if (nodes!=null || edges!=null) {
                m_head=m_tail=null;
                Iterator iterator=m_nodeMovement.values().iterator();
                while (iterator.hasNext()) {
                    NodeMovement nodeMovement=(NodeMovement)iterator.next();
                    add(new SubGraph(nodeMovement));
                }
                if (edges!=null) {
                    iterator=edges.iterator();
                    while (iterator.hasNext()) {
                        Edge edge=(Edge)iterator.next();
                        nodeChanged(edge.getFrom());
                        nodeChanged(edge.getTo());
                    }
                }
                iterator=m_graph.getEdges().iterator();
                while (iterator.hasNext()) {
                    Edge edge=(Edge)iterator.next();
                    addNode(edge.getFrom());
                    addNode(edge.getTo());
                    addEdge(edge);
                }
            }
        }
        public void mergeSubGraphs(SubGraph subGraph1,SubGraph subGraph2) {
            if (subGraph1.getSize()<subGraph2.getSize()) {
                subGraph2.mergeWith(subGraph1);
                remove(subGraph1);
            }
            else {
                subGraph1.mergeWith(subGraph2);
                remove(subGraph2);
            }
        }
    }

    /**
     * Information about a subgraph.
     */
    protected static class SubGraph extends ListNode {
        protected SubGraphList m_nodes;

        public SubGraph(NodeMovement nodeMovement) {
            m_nodes=new SubGraphList(this);
            m_nodes.add(nodeMovement);
            nodeMovement.m_list=m_nodes;
        }
        public NodeMovement getFirstNodeMovement() {
            return (NodeMovement)m_nodes.m_head;
        }
        public void mergeWith(SubGraph subGraph) {
            m_nodes.mergeWith(subGraph.m_nodes);
        }
        public void removeNodeMovement(NodeMovement nodeMovement) {
            m_nodes.remove(nodeMovement);
        }
        public int getSize() {
            return m_nodes.m_size;
        }
    }

    protected static class SubGraphList extends ListOfNodes {
        public SubGraph m_subGraph;

        public SubGraphList(SubGraph subGraph) {
            m_subGraph=subGraph;
        }
    }
}