root/trunk/JGraphViewer.java

// JGraphViewer.java
//
// This is a JComponent that shows a Graph, including its nodes, edges, and
// maps, on the screen in a customizable manner, and informs interested parties
// when MouseEvents happen on it.
//
// To be informed when mouse events happen, implement PointListener and use
// addPointListener() to register yourself.  When mouse events occur, their
// coordinates will be translated to a real-space point and sent to you.
//
// The scale is how many pixels are used to represent one unit in the real
// coordinate system, and it can be changed with the associated functions.
// Space can also be added on the sides, allowing users to scroll outside the
// actual bounds of the graph so they can, for example, add nodes there.
//
// The way nodes, edges, and maps appear is dictated by ObjectPainters, which
// are specific to a type.  To change the appearance of an object or set of
// objects, the first step is to create an ObjectPainter of the appropriate
// type representing the attributes you want.  You can make this ObjectPainter
// be used for objects that don't have a more specific one with
// setDefault*Painter().  setPath*Painter() sets the painter for objects on
// the path, and setPath() sets this path.  setSelected*Painter() sets the
// painter for the selected object, and the selected object can be set with
// setSelectedObject().
//
// Currently maps are implemented outside the ObjectPainter system because they
// are not associated with Graphs, and because they have no parameters that
// affect how they're drawn.  This could be changed in the future, especially
// if maps are to be serializable and owned by graphs.  The reason maps
// currently aren't serializable is because half of what they are (how they
// name their files) is embodied in a special class, one per map.

import java.awt.*;
import java.awt.event.*;
import java.awt.geom.*;
import java.awt.image.*;
import java.util.*;
import javax.swing.*;
import java.math.*;

class JGraphViewer extends JPanel implements GraphChangeListener {

        public JGraphViewer(Graph graph, double scaleX, double scaleY, BackgroundMap backgroundMap) {
                // Note - most of our members get initialized where they're
                // declared - cool, huh?  Yay Java.

                // we must use a borderlayout, or else the scrollPane doesn't
                // get resized when we do.  Alternately, we could derive from
                // the scrollpane instead of containing it, but that might let
                // people screw with us too much.  (Maybe worth it anyway?)
                // (Just s/scrollPane/this/, change above to JScrollPane.)

                super(new BorderLayout());

                add(scrollPane);

                scale = AffineTransform.getScaleInstance(scaleX, scaleY);
                setGraph(graph);
                setBackgroundMap(backgroundMap);


                // This is a workaround for what I can only conclude is a Swing
                // bug.  It makes scrolling slower, because it redraws the
                // entire visible area, not just the newly exposed area.

                // The bug is, when scrolling exposes a new map tile, when the
                // map tile loads, the parts of the tile that were exposed
                // during the scroll but before the tile's image was loaded
                // are sometimes not repainted, leaving black areas.

                // I have confirmed that the imageUpdate events are received by
                // the drawingPane, and I have attempted calling repaint() and
                // paintImmediately(0,0,inf,inf) when they are received, as well
                // as turning off double buffering, but this is the only way
                // the problem doesn't appear.

                // It has appeared in with Sun 1.5, Blackdown 1.4, and something
                // on Windows.

                // The bug seems mostly worked around with my new imageobserver,
                // so i'll comment out the complete workaround for now...

                //scrollPane.getViewport().setScrollMode(JViewport.SIMPLE_SCROLL_MODE);
        }

        /**
         * This must be called whenever a change is made to our graph,
         * especially if the area could have changed.  (It isn't necessary to
         * call this after modifying painters, though.)
         */
        public void graphChanged() {
                graphRectangle = null;
                objectsToPainters = null;
                paintersToObjectLists = null;

                drawingPane.repaint();
        }

        // the space functions control how much blank space is left around the
        // graph.  This is so you can add points that are outside the current
        // bounding rectangle.

        public void addSpace(double top, double bottom, double left, double right) {
                // calls setSpace()
                // todo: implement

        }
        public void setSpace(double top, double bottom, double left, double right) {
                // makes us have this much space, in screen coordinates, on our
                // sides, so that someone can add stuff by clicking in that
                // area.

                //todo: implement
        }

        // these let you get or set the graph we use.
        public Graph getGraph() { return graph; }
        public void setGraph(Graph graph) {
                // this triggers an unnecessary immediate repaint, which I
                // unfortunately can't avoid.
                scrollPane.getViewport().setViewPosition(new Point(0, 0));

                clearAllSpecialNodes();
                this.graph = graph;
                if(graph != null) graph.addGraphChangeListener(this);
                graphChanged();
                computeAndChangePreferredSize();
                drawingPane.repaint();
        }

        // these let you manipulate the scale, in px/m.
        public double getScaleX() { return scale.getScaleX(); }
        public double getScaleY() { return scale.getScaleY(); }
        public void setScale(double scaleX, double scaleY) {
                Point2D.Double center = getVisibleRegionCenter();
                scale = AffineTransform.getScaleInstance(scaleX, scaleY);
                realToScreen = null;
                setVisibleRegionCenter(center);
        drawingPane.repaint();
        }

        // these let you register your interest in translated mouse events.
        public void addPointListener(PointListener pointListener) {
                pointListeners.add(pointListener);
        }

        public Collection getPointListeners() { return pointListeners; }
        public void removePointListener(PointListener pointListener) {
                pointListeners.remove(pointListener);
        }


        // not sure if overriding this instead of making my own function is best
        public void setBackground(Color bg) {
                if(drawingPane != null) drawingPane.setBackground(bg);
        }


        public Path getPath() { return path; }
        public void setPath(Path path) {
                // Case of NULL should do just fine.
                this.path = path;
                objectsToPainters = null;
                drawingPane.repaint();
        }

        public Object getSelectedObject() { return selectedObject; }
        public void setSelectedObject(Object object) {
                selectedObject = object;
                objectsToPainters = null;
                drawingPane.repaint();
        }

        public BackgroundMap getBackgroundMap() { return backgroundMap; }
        // null map is ok
        public void setBackgroundMap(BackgroundMap backgroundMap) {
                Point2D.Double center = getVisibleRegionCenter();
                this.backgroundMap = backgroundMap;
                graphRectangle = null;
                setVisibleRegionCenter(center);
                drawingPane.repaint();
        }

        // zOrder is 0 for on top, 1 for under selection but over path, and
        // 2 for under everything.
        public void addCustomObjectPainter(Object object, int zOrder, ObjectPainter painter) {
                objectsToCustomPainters[zOrder].put(object, painter);
                objectsToPainters = null;
                drawingPane.repaint();
        }

        public void clearCustomObjectPainters() {
                for(int i = 0; i < objectsToCustomPainters.length; i++) {
                        objectsToCustomPainters[i].clear();
                }
                objectsToPainters = null;
                drawingPane.repaint();
        }
        public void clearAllSpecialNodes() {
                setPath(null);
                setSelectedObject(null);
                clearCustomObjectPainters();
        }

        public PhysicalNodePainter getDefaultNodePainter() { return defaultNodePainter; }
        public void setDefaultNodePainter(PhysicalNodePainter painter) {
                defaultNodePainter = painter;
                objectsToPainters = null;
                drawingPane.repaint();
        }

        public PhysicalEdgePainter getDefaultEdgePainter() { return defaultEdgePainter; }
        public void setDefaultEdgePainter(PhysicalEdgePainter painter) {
                defaultEdgePainter = painter;
                objectsToPainters = null;
                drawingPane.repaint();
        }

        public void setPathNodePainter(PhysicalNodePainter painter) {
                pathNodePainter = painter;
                objectsToPainters = null;
                drawingPane.repaint();
        }

        public void setPathEdgePainter(PhysicalEdgePainter painter) {
                pathEdgePainter = painter;
                objectsToPainters = null;
                drawingPane.repaint();
        }

        public void setSelectedNodePainter(PhysicalNodePainter painter) {
                selectedNodePainter = painter;
                objectsToPainters = null;
                drawingPane.repaint();
        }

        public void setSelectedEdgePainter(PhysicalEdgePainter painter) {
                selectedEdgePainter = painter;
                objectsToPainters = null;
                drawingPane.repaint();
        }




        public Object closestMatch(Point2D.Double realPoint, double maxDistance) {
                updateRealToScreen();
                updateObjectsToPainters();

                Object closestMatch = null;

                Iterator iterator = objectsToPainters.entrySet().iterator();
                while(iterator.hasNext()) {
                        Map.Entry entry = (Map.Entry)iterator.next();
                        ObjectPainter painter = (ObjectPainter)entry.getValue();
                        Object object = entry.getKey();

                        double distance = painter.visualDistanceTo(object, realPoint, backgroundMap, realToScreen);

                        if(distance < maxDistance) {
                                closestMatch = object;
                        }
                }
                return closestMatch;
        }

        /*
         * The following functions return true if their objects aren't null
         * and the update functions for all the things they depend on return
         * true.  In this way, the functions ensure their objects are up-to-date
         * when the call returns.  To mark an object as not up-to-date, set it
         * to null.  You need not set objects that depend on it to null, because
         * the dependency graph in implicit in the update*() functions.  Just
         * call the appropriate update*() function when you need that object
         * to be up-to-date.
         */

        /**
         * This function computes, if necessary, objectsToPainters, which is a
         * map that tells us, for every object we need to paint, which
         * ObjecPainter to use.  It returns true and does nothing if
         * objectsToPainters was already up-to-date, otherwise, it returns
         * false.
         */
        private boolean updateObjectsToPainters() {

                // return early if we're up-to-date.
                if(objectsToPainters != null)
                        return true;

                // a LinkedHashMap will be iterated through in the order keys
                // were inserted, so we can ensure that all edges are drawn
                // before all nodes.

                if(graph == null) {
                        objectsToPainters = new LinkedHashMap();
                        return false;
                }

                objectsToPainters = new LinkedHashMap(graph.getNodes().size() + graph.getEdges().size());

                Iterator iterator;

                // add all the edges with the default painter
                if(defaultEdgePainter != null) {
                        iterator = graph.getEdges().iterator();
                        while(iterator.hasNext()) {
                                Edge edge = (Edge)iterator.next();
                                if(!(edge instanceof PhysicalEdge)) continue;
                                objectsToPainters.put(edge, defaultEdgePainter);
                        }
                }

                // add all the nodes with the default painter
                if(defaultNodePainter != null) {
                        iterator = graph.getNodes().iterator();
                        while(iterator.hasNext()) {
                                Node node = (Node)iterator.next();
                                if(!(node instanceof PhysicalNode)) continue;
                                objectsToPainters.put(node, defaultNodePainter);
                        }
                }

                objectsToPainters.putAll(objectsToCustomPainters[2]);

                // add all the nodes in the path (this doesn't affect
                // LinkedHashSet order, so this is ok assuming the path only
                // has nodes in the graph.)
                if(path != null) {
                        // add all the edges with the path painter
                        if(pathEdgePainter != null) {
                                iterator = path.edges.iterator();
                                while(iterator.hasNext()) {
                                        Edge edge = (Edge)iterator.next();
                                        if(!(edge instanceof PhysicalEdge)) continue;
                                        objectsToPainters.put(edge, pathEdgePainter);
                                }
                        }

                        // add all the nodes with the path painter
                        if(pathNodePainter != null) {
                                iterator = path.nodes.iterator();
                                while(iterator.hasNext()) {
                                        Node node = (Node)iterator.next();
                                        if(!(node instanceof PhysicalNode)) continue;
                                        objectsToPainters.put(node, pathNodePainter);
                                }
                        }
                }

                objectsToPainters.putAll(objectsToCustomPainters[1]);


                // add in the selected object with the proper painter
                if(selectedObject instanceof PhysicalEdge) {
                        objectsToPainters.put(selectedObject, selectedEdgePainter);
                } else if(selectedObject instanceof PhysicalNode) {
                        objectsToPainters.put(selectedObject, selectedNodePainter);
                }

                objectsToPainters.putAll(objectsToCustomPainters[0]);

                paintersToObjectLists = null;
                //assert objectsToPainters != null;

                return false;
        }

        /**
         * This function computes, if necessary, paintersToObjectLists, which
         * maps each painter to a list of the objects that should be painted by
         * it.  It's more efficient to draw groups of objects that use the same
         * ObjectPainter at the same time, which is why we use such a map. It
         * returns true and does nothing if paintersToObjectLists was already
         * up-to-date, otherwise, it returns false.
         */
        private boolean updatePaintersToObjectLists() {
                // return early if we're up-to-date
                boolean upToDate = true;
                upToDate &= updateObjectsToPainters();
                upToDate &= (paintersToObjectLists != null);
                if(upToDate) return true;

               // assert(objectsToPainters != null);

                // a LinkedHashSet preserves the order
                paintersToObjectLists = new LinkedHashMap();

                // for each key-value pair in objectsToPainters...
                Iterator iterator = objectsToPainters.entrySet().iterator();
                while(iterator.hasNext()) {
                        Map.Entry entry = (Map.Entry)iterator.next();
                        // get the painter for this key-value pair
                        ObjectPainter painter = (ObjectPainter)entry.getValue();
                        // get the associated list, creating it if necessary
                        LinkedList list = (LinkedList)paintersToObjectLists.get(painter);
                        if(list == null) {
                                list = new LinkedList();
                                paintersToObjectLists.put(painter, list);
                        }
                        // add the paintable object to the list
                        list.add(entry.getKey());
                }

                // assert(paintersToObjectLists != null);
                return false;
        }

        /**
         * This computes graphRectangle if necessary.  It returns true and does
         * nothing if graphRectangle was already up-to-date, otherwise, it
         * returns false.
         */
        private boolean updateGraphRectangle() {

                // return early if we're up-to-date
                boolean upToDate = true;
                upToDate &= (graphRectangle != null);
                if(upToDate) return true;

                graphRectangle = new Rectangle2D.Double();
                if(backgroundMap != null)
                        graphRectangle.setRect(backgroundMap.getRealBoundingRectangle());

                // assert(graphRectangle != null);
                return false; // because we weren't already up-to-date.
        }

        /**
         * This function computes realToScreen, if necessary.  It returns true
         * and does nothing if realToScreen was already up-to-date, otherwise it
         * returns false.
         */
        private boolean updateRealToScreen() {
                // return early if we're up-to-date
                boolean upToDate = true;
                upToDate &= updateGraphRectangle();
                upToDate &= (realToScreen != null);

                if(upToDate) return true;

                // assert(graphRectangle != null);

                computeAndChangePreferredSize();

                // here's 2 defining corners of that rectangle
                Point2D.Double corners[] = { new Point2D.Double(graphRectangle.x, graphRectangle.y),
                                             new Point2D.Double(graphRectangle.x + graphRectangle.width,
                                                                graphRectangle.y + graphRectangle.height)};

                // transform the corners to screen coordinates
                scale.transform(corners, 0, corners, 0, 2);

                // if we are supposed to have extra space, we should add it now

                // find the lowest coordinates
                double minX = Math.min(corners[0].x, corners[1].x);
                double minY = Math.min(corners[0].y, corners[1].y);

                // make a slide transform so everything onscreen is positive.
                // we round it off because non-integer translations will make
                // the map look fuzzy even at 1:1 scale.
                realToScreen = AffineTransform.getTranslateInstance((double)(int)-minX, (double)(int)-minY);
                realToScreen.concatenate(scale);

                // assert(realToScreen != null);
                return false;
        }

        private void computeAndChangePreferredSize() {
                if(dontComputeAndChangePreferredSize) return;

                updateGraphRectangle();

                // we can set our preferred size here
                drawingPane.setPreferredSize(new Dimension(
                        (int)(graphRectangle.width * scale.getScaleX() + 1),
                        (int)(graphRectangle.height * scale.getScaleY() + 1)
                ));

                // update our scrollbars's unit scroll
                // the size of our visible area, I think.
                Dimension viewportSize = ((JViewport)drawingPane.getParent()).getSize();
                // our size
                Dimension preferredSize = drawingPane.getPreferredSize();

                // make there be only 30 scroll-stops, unless that would
                // reqiure scrollying more than 1/15 of what we can.
                scrollPane.getHorizontalScrollBar().setUnitIncrement(
                        Math.min(
                                Math.max(1, (preferredSize.width - viewportSize.width) / 30),
                                Math.max(1, viewportSize.width / 15)
                        )
                );
                scrollPane.getVerticalScrollBar().setUnitIncrement(
                        Math.min(
                                Math.max(1, (preferredSize.height - viewportSize.height) / 30),
                                Math.max(1, viewportSize.height / 15)
                        )
                );



        }