root/trunk/PhysicalNodePainter.java

/**
 * PhysicalNodePainter.java
 *
 * This class represents a way to draw a PhysicalNode on the screen, and its
 * instances can be used to draw any PhysicalNode on the screen in the way it
 * represents.  JGraphViewer will have several of these associated with
 * PhysicalNodes, and it will use them to draw those PhysicalNodes.  Objects
 * of this type will also be able to determine how close a mouse-click on a
 * given point is to the on-screen representation of a PhysicalNode.
 */

import java.awt.*;
import java.awt.geom.*;
import java.util.*;

public class PhysicalNodePainter extends ObjectPainter {

        public PhysicalNodePainter(Color color, float radius) {
                setColor(color);
                setRadius(radius);
        }

        public PhysicalNodePainter() {
                setColor(Color.BLACK);
                setRadius(2);
        }

        public Color getColor() { return color; }
        public void setColor(Color color) { this.color = color; }
        // when you type color enough, the word loses all meaning :)

        // radius is in pixels
        public float getRadius() { return radius; }
        public void setRadius(float radius) { this.radius = radius; }
        // it'd be cool if Java could automate trivial get/set functions

        public double visualDistanceTo(Object object, Point2D.Double real, BackgroundMap map, AffineTransform realToScreen) {
                // convert both points to screen, return their distance less radius
                if(!((PhysicalNode)object).isOnMap(map)) return Double.POSITIVE_INFINITY;
                return realToScreen.transform(real, null).distance(
                        ((Point2D.Double)computeLocation(object, realToScreen)))
                        - radius;
        }

        protected void setupPainting(Graphics2D g) {
                g.setColor(color);
                g.setStroke(new BasicStroke());
                cachedEllipse.width = cachedEllipse.height = 2 * radius;
        }

        protected Object computeLocation(Object object, AffineTransform realToScreen) {
                 return realToScreen.transform(((PhysicalNode) object).point, null);
        }

        protected boolean needToPaint(Object object, Object location, BackgroundMap map, Graphics2D g) {
                if(!((PhysicalNode)object).isOnMap(map)) return false;
                return true;
        }

        protected void paintSingleObject(Object object, Object location, Graphics2D g) {
                Point2D.Double screenPoint = (Point2D.Double)location;
                cachedEllipse.x = screenPoint.getX() - radius;
                cachedEllipse.y = screenPoint.getY() - radius;

                g.fill(cachedEllipse);
        }

        Color color; // the color we use to draw the node
        float radius;  // how big the node should be drawn

        Ellipse2D.Double cachedEllipse = new Ellipse2D.Double();

        // Later, we will have multiple modes, for example, a mode for drawing
        // the nodes as a point, or a mode for drawing them with a picture.
        // Alternately, the same thing could be done by subclassing this.
}