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)
                        )
                );



        }

        /**
         * This is a special type of JPanel that knows how to paint itself with
         * all of our components.  It's an nested class, which means it has
         * access to all the parent class's fields, which means we don't have
         * to make a bunch of functions in JGraphViewer that just forward
         * themselves to the JSimpleGraphViewer.
         */
        private class DrawingPane extends JPanel implements MouseListener, MouseMotionListener {
                public DrawingPane() {
                        addMouseListener(this);
                        addMouseMotionListener(this);
                }

                protected void paintComponent(Graphics graphics) {
                        super.paintComponent(graphics);
                        if(dontPaint) {
                            System.out.println("superfluous paint, please report");
                        }

                        // we really always have a Graphics2D, Java just uses
                        // Graphics for backward-compatibility.
                        Graphics2D g = (Graphics2D)graphics.create();

                        // this prevents line endpoints from being rounded to
                        // the nearest pixel, which prevents lines from
                        // "jittering" when the window is resized.
                        g.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL,
                                           RenderingHints.VALUE_STROKE_PURE);


                        // We draw crappily if we're moving, nicely otherwise.
                        if(!highQuality ||
                           scrollPane.getHorizontalScrollBar().getValueIsAdjusting() ||
                           scrollPane.getVerticalScrollBar().getValueIsAdjusting() ||
                           temporaryLowQuality) {
                                // we are adjusting, so set it for crappy:
                                g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                                   RenderingHints.VALUE_ANTIALIAS_OFF);
                                g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                                                   RenderingHints.VALUE_INTERPOLATION_NEAREST_NEIGHBOR);
                                // and schedule a redraw after we have stopped
                                // moving
                                if(highQuality)
                                        goodRepainter.scheduleGoodRepaint();
                        } else {
                                // we aren't adjusting, so we set high-quality
                                g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
                                                   RenderingHints.VALUE_ANTIALIAS_ON);
                                g.setRenderingHint(RenderingHints.KEY_INTERPOLATION,
                                                   RenderingHints.VALUE_INTERPOLATION_BICUBIC);
                        }

                        // make sure everything we use is up-to-date
                        updatePaintersToObjectLists();
                        updateRealToScreen();

                        if(backgroundMap != null) {
                                if(backgroundMap instanceof TiledMap) {
                                        // draw the map
                                        // we need this crappy imageobserver to trigger a redraw
                                        // manually because java is buggy and otherwise it won't
                                        // redraw images that have loaded while we're scrolling.                                
                                        backgroundMap.paint(g, realToScreen, new ImageObserver() {
                                                public boolean imageUpdate(Image img, int infoflags, int x, int y, int width, int height) {
                                                        if((infoflags & ImageObserver.ALLBITS) != 0) {
                                                                System.out.println("the image is loaded");
                                                                SwingUtilities.invokeLater(new Runnable() {
                                                                        public void run() {
                                                                                repaint();
                                                                        }
                                                                });
                                                                return false;
                                                        } else {
                                                                return true;
                                                        }
                                                }
                                        });
                                } else {
                                        backgroundMap.paint(g, realToScreen, this);     
                                }
                        }

                        // draw all the objects
                        Iterator iterator = paintersToObjectLists.entrySet().iterator();
                        while(iterator.hasNext()) {
                                Map.Entry entry = (Map.Entry)iterator.next();
                                ((ObjectPainter)entry.getKey()).paintObjects(
                                        ((Collection)entry.getValue()), realToScreen, backgroundMap, g
                                );
                        }
                }

                // This nested class maintains a single thread that schedules a
                // repaint for after the scrollbars have stopped moving.
                public class GoodRepainter {
                        // calling this will schedule a repaint to occur after
                        // the scrollbars have stopped being adjusted.
                        public void scheduleGoodRepaint() {
                                if(needRepaint == false) {
                                        needRepaint = true;
                                        (new Thread(new Runnable() {
                                                public void run() {
                                                        while(scrollPane.getHorizontalScrollBar().getValueIsAdjusting() ||
                                                               scrollPane.getVerticalScrollBar().getValueIsAdjusting() ||
                                                                   temporaryLowQuality) {
                                                                try {
                                                                        Thread.sleep(25);
                                                                } catch(InterruptedException e) {}
                                                        }
                                                        SwingUtilities.invokeLater(new Runnable() {
                                                                public void run() {
                                                                        repaint();
                                                                        needRepaint = false;
                                                                }
                                                        });
                                                }
                                        }, "GoodRepainter")).start();
                                }
                        }
                        private boolean needRepaint;
                }

                public void setPreferredSize(Dimension preferredSize) {
                        super.setPreferredSize(preferredSize);
                        // this causes the first paint to usually be
                        // unnecessary, but I don't know how to avoid that.
                        revalidate();
                }

                /*
                 * Here's all the mouse handling stuff.  It's here instead of
                 * in the parent so it doesn't interfere with the parent's
                 * possible attempts to do "hand-scrolling".
                 */

                // these events get translated and forwarded to our PointListeners.
                // MouseListener:
                public void mouseClicked (MouseEvent event) { dispatchMouseEvent(event); }
                public void mouseEntered (MouseEvent event) { dispatchMouseEvent(event); }
                public void mouseExited  (MouseEvent event) { dispatchMouseEvent(event); }
                public void mousePressed (MouseEvent event) { dispatchMouseEvent(event); }
                public void mouseReleased(MouseEvent event) { dispatchMouseEvent(event); }
                // MouseMotionListener:
                public void mouseDragged (MouseEvent event) { dispatchMouseEvent(event); }
                public void mouseMoved   (MouseEvent event) { dispatchMouseEvent(event); }


                /**
                * This translates the event's point to real space, then forwards
                * it and the translated point to our PointListeners
                */
                private void dispatchMouseEvent(MouseEvent event) {
                        // we assume realToScreen is the same transform that
                        // was used to draw the currently-visible points on the screen,
                        // which will almost always be the case.  Things could get weird
                        // if the user resizes the window and then clicks a point before
                        // the window is fully redrawn.  Oh well.

                        if(realToScreen == null) return;
                        try {
                                // transform from screen to real coordinates
                                Point2D.Double screenPoint = new Point2D.Double(event.getX(), event.getY());
                                Point2D.Double realPoint = new Point2D.Double();
                                realToScreen.inverseTransform(screenPoint, realPoint);

                                // notify each pointlistener
                                Iterator iterator = pointListeners.iterator();
                                while(iterator.hasNext()) {
                                        PointListener pointListener = (PointListener)iterator.next();
                                        pointListener.pointReceived(event, realPoint);
                                }
                        } catch(NoninvertibleTransformException exception) {
                                // This should never happen, but we need to tell Java it won't.
                                System.out.println("Couldn't inverse transform the point");
                        }
                }

                // allows us to schedule "good" repaints for later.
                private GoodRepainter goodRepainter = new GoodRepainter();
        };

        // Between 0 (showing whole map) and 1 (pixel for pixel), can be above 1
        public void scaleRelative(double zoom) {
                System.out.println("scaleRelative: " + zoom + " " + temporaryLowQuality);
                if(backgroundMap == null) return;
                double fudge = 1; // almost 1
                
                // todo - make this 1 px less than the size it could be if there were no scrollbars
                Dimension currentVisibleSize = scrollPane.getViewport().getExtentSize();//getSize();
                
                updateGraphRectangle();
                
                double zeroScale = Math.min(
                        currentVisibleSize.width * fudge / graphRectangle.width,
                        currentVisibleSize.height * fudge / graphRectangle.height
                );
                
                
                double oneScale = backgroundMap.getPixelForPixelScale();
                double scale;
                if(zoom <= 1)
                        scale = (oneScale - zeroScale) * zoom + zeroScale;
                else
                        scale = oneScale * zoom;                
                
                setScale(scale, scale);
        }

        public Point2D.Double getVisibleRegionCenter() {
                updateRealToScreen();

                Rectangle rect = scrollPane.getViewport().getViewRect();
                Point2D.Double point = new Point2D.Double(
                        rect.x + rect.width / 2,
                        rect.y + rect.height / 2
                );

                try {
                        realToScreen.inverseTransform(point, point);
                } catch(NoninvertibleTransformException e) {
                        System.out.println("Couldn't invert the transform.");
                }

                return point;
        }

        public void setVisibleRegionCenter(Point2D.Double newCenter) {
                dontComputeAndChangePreferredSize = true;
                updateRealToScreen();
                dontComputeAndChangePreferredSize = false;


                Point screenPoint = new Point();
                realToScreen.transform(newCenter, screenPoint);

                // there really should be no paints before this point, as we shouldn't
                // have done anything

                JViewport viewport = scrollPane.getViewport();


                Rectangle rect = viewport.getViewRect();

                int oldScrollMode = viewport.getScrollMode();
                viewport.setScrollMode(JViewport.SIMPLE_SCROLL_MODE);

                // these two actions really ought to be atomic
                dontPaint = true;
                computeAndChangePreferredSize();
                dontPaint = false;
                viewport.setViewPosition(new Point(
                        (int)(screenPoint.x - rect.width / 2),
                        (int)(screenPoint.y - rect.height / 2)
                ));

                viewport.setScrollMode(oldScrollMode);
        }

        // whether we should try to render the map at highest quality
        public void setHighQuality(boolean b) { highQuality = b; }

        // if someone's dragging a slider or something, set this
        // make darn sure to unset it at some point
        public void setTemporaryLowQuality(boolean b) { temporaryLowQuality = b; }

        /// here's the graph we refer to
        private Graph graph;

        /// a rectangle, in real coordinates, that contains all visible things.
        private Rectangle2D.Double graphRectangle;
        /// tells us how to scale points from real to screen, but does not
        /// slide the coordinates so they're all positive
        private AffineTransform scale;
        /// tells us how to translate stuff to the screen so it's positive
        private AffineTransform realToScreen;

        /// this is the drawing pane
        private DrawingPane drawingPane = new DrawingPane();
        /// this is the scrollbars
        private JScrollPane scrollPane = new JScrollPane(drawingPane);

        /**
         * These are cached because they're slow to recompute
         * Set objectsToPainters to null when they must be updated.
         */
        private Map objectsToPainters;
        private Map paintersToObjectLists;

        /// default painters
        private PhysicalNodePainter defaultNodePainter = new PhysicalNodePainter(Color.BLACK, 3);
        private PhysicalEdgePainter defaultEdgePainter = new PhysicalEdgePainter(Color.BLACK, (float)1.5);

        /// The path we're showing
        private Path path;
        /// How to draw nodes and edges on that path
        private PhysicalNodePainter pathNodePainter = new PhysicalNodePainter(Color.BLUE, 5);
        private PhysicalEdgePainter pathEdgePainter = new PhysicalEdgePainter(Color.BLUE, 5);

        /// The currently selected object
        private Object selectedObject;
        /// How to draw it, depending on what type of thing it is
        private PhysicalNodePainter selectedNodePainter = new PhysicalNodePainter(Color.RED, 7);
        private PhysicalEdgePainter selectedEdgePainter = new PhysicalEdgePainter(Color.RED, 7);

        /// Custom drawing commands
        private Map objectsToCustomPainters [] = {new HashMap(), new HashMap(), new HashMap()};

        /// Allows us to inform others about mouse events we receive
        private Collection pointListeners = new LinkedList();

        /// the backgroundmaps we draw
        private BackgroundMap backgroundMap;

        private boolean dontComputeAndChangePreferredSize = false;
        private boolean dontPaint = false;

        private boolean highQuality = true;
        private boolean temporaryLowQuality = false;
}