root/trunk/PhysicalEdgePainter.java

/**
 * PhysicalEdgePainter.java
 *
 * This class represents a way to draw a PhysicalEdge on the screen, and its
 * instances can be used to draw any PhysicalEdge on the screen in the way it
 * represents.  JGraphViewer will have several of these associated with
 * PhysicalEdges, and it will use them to draw those PhysicalEdges.  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 PhysicalEdge.
 */

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

public class PhysicalEdgePainter extends ObjectPainter {

        public PhysicalEdgePainter(Color color, float thickness) {
                setColor(color);
                setThickness(thickness);
        }

        public PhysicalEdgePainter() {
                setColor(Color.BLACK);
                setThickness(1);
        }

        public Color getColor() { return color; }
        public void setColor(Color color) { this.color = color; }

        // thickness is in pixels
        public float getThickness() { return thickness; }
        public void setThickness(float thickness) { this.thickness = thickness; }

        public double visualDistanceTo(Object object, Point2D.Double real, BackgroundMap map, AffineTransform realToScreen) {
                if(!((PhysicalEdge)object).isOnMap(map)) return Double.POSITIVE_INFINITY;                
                return ((Line2D.Double)computeLocation(object, realToScreen)).ptSegDist(
                        realToScreen.transform(real, null))
                        - thickness / 2;
        }

        protected void setupPainting(Graphics2D g) {

                g.setColor(color);
                g.setStroke(new BasicStroke(thickness));
        }

        protected Object computeLocation(Object object, AffineTransform realToScreen) {
                // casts make this look more complicated than it is; it really
                // just gets the endpoints of the edge, transforms them, and
                // makes them into a line.

                return new Line2D.Double(
                        realToScreen.transform(((PhysicalNode)((PhysicalEdge)object).getNodeA()).point, null),
                        realToScreen.transform(((PhysicalNode)((PhysicalEdge)object).getNodeB()).point, null)
                );
        }

        protected boolean needToPaint(Object object, Object location, BackgroundMap map, Graphics2D g) {
                if(!((PhysicalEdge)object).isOnMap(map)) return false;
                return g.getClipBounds(new Rectangle()).intersectsLine((Line2D)location);
        }

        protected void paintSingleObject(Object object, Object location, Graphics2D g) {
                g.draw((Line2D.Double)location);
        }

        Color color; // the color we use to draw the edge
        float thickness;  // how thick it should be

        // 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.
}