textshapedecoration.java

openmap java写的开源数字地图程序. 用applet实现,可以像google map 那样放大缩小地图.

package com.bbn.openmap.omGraphics.awt;

import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.geom.AffineTransform;
import java.awt.geom.Point2D;
import java.awt.image.BufferedImage;
import java.util.LinkedList;

/**
 * A ShapeDecoration that draws a text along a path
 * 
 * @author Eric LEPICIER
 * @version 16 ao鹴 2002
 */
public class TextShapeDecoration extends AbstractShapeDecoration {
    private String text;
    private Font font = null;
    private int verticalAlignment = BASELINE;

    /** Baseline vertical alignment */
    public final static int BASELINE = 1;
    /** Center vertical alignment */
    public final static int CENTER = 2;
    /** Top vertical alignment */
    public final static int TOP = 3;
    /** Bottom vertical alignment */
    public final static int BOTTOM = 4;

    /** Orientation for the shape text decoration: use poly direction */
    public final static int FORWARD = LEFT;
    /**
     * Orientation for the shape text decoration: use reverse poly
     * direction
     */
    public final static int BACKWARD = RIGHT;
    /** Orientation for the shape text decoration: force left to right */
    public final static int LEFT_TO_RIGHT = 3;
    /** Orientation for the shape text decoration: force right to left */
    public final static int RIGHT_TO_LEFT = 4;
    /** Orientation for the shape text decoration: force top to bottom */
    public final static int TOP_TO_BOTTOM = 5;
    /** Orientation for the shape text decoration: force bottom to top */
    public final static int BOTTOM_TO_TOP = 6;
    /**
     * Orientation for the shape text decoration: occidental reading
     * use
     */
    public final static int MOST_READABLE = 7;

    /**
     * Text will follow the poly instead of being written on the
     * segment from begin to end of the poly, also allow text to be
     * uncomplete. You may add this one to the other constants
     */
    public final static int FOLLOW_POLY = 16;

    private transient FontMetrics metrics;
    private transient Graphics2D g2D = null;

    /**
     * Constructor.
     * 
     * @param text
     * @param font
     * @param orientation
     * @param verticalAlignment
     */
    public TextShapeDecoration(String text, Font font, int orientation,
            int verticalAlignment) {
        super(0.0f, 0.0f, orientation);
        setVerticalAlignment(verticalAlignment);
        setFont(font);
        setText(text);
        initMetrics();
    }

    /**
     * Constructor.
     * 
     * @param text
     */
    public TextShapeDecoration(String text) {
        super(0.0f, 0.0f, FORWARD);
        setVerticalAlignment(BASELINE);
        setText(text);
        initMetrics();
    }

    /**
     * init Metrics used to get string graphic length.
     * 
     * @param object
     */
    private void initMetrics() {
        if (g2D == null)
            g2D = (Graphics2D) new BufferedImage(10, 10, BufferedImage.TYPE_INT_RGB).getGraphics();
        if (font == null)
            font = g2D.getFont();
        metrics = g2D.getFontMetrics(font);
    }

    /**
     * Draws the text along the polyline
     * 
     * @see com.bbn.openmap.omGraphics.awt.ShapeDecoration#draw(Graphics,
     *      Point2D[], boolean)
     */
    public void draw(Graphics g, Point2D[] points, boolean complete) {

        g2D = (Graphics2D) g;
        initMetrics();
        g.setFont(font);

        int x1 = (int) points[0].getX();
        int y1 = (int) points[0].getY();
        int x2 = (int) points[points.length - 1].getX();
        int y2 = (int) points[points.length - 1].getY();

        boolean reverse = needToReverse(x1, y1, x2, y2);

        // draw the text exactly on the curve, even uncomplete
        if ((getOrientation() & FOLLOW_POLY) > 0) {
            drawFollow(g, points, reverse);
            return;
        }

        // if there's not enough room, do nothing
        if (!complete)
            return;

        // else plot the text straight on the half segment
        // from start to end point and away
        int x, y;
        double angle;
        if (reverse) {
            x = x2;
            y = y2;
            angle = Math.atan2(y1 - y2, x1 - x2);
        } else {
            x = x1;
            y = y1;
            angle = Math.atan2(y2 - y1, x2 - x1);
        }

        // adjust vertical alignment
        switch (verticalAlignment) {
        case TOP:
            y += metrics.getAscent();
            break;
        case BOTTOM:
            y -= metrics.getDescent();
            break;
        case CENTER:
            y += metrics.getAscent() - (metrics.getHeight()) / 2;
            break;
        case BASELINE:
            break;
        }

        drawAngledString(g, text, x, y, angle);
    }

    /**
     * Returns true if the polyline need to be reverted for the text
     * to be drawn with the specified orientation.
     * 
     * @param x1 starting point x coordinate
     * @param y1 starting point y coordinate
     * @param x2 ending point x coordinate
     * @param y2 ending point y coordinate
     * @return boolean
     */
    protected boolean needToReverse(int x1, int y1, int x2, int y2) {
        boolean reverse = false;
        switch (getOrientation() & ~FOLLOW_POLY) {
        case FORWARD:
            break;
        case BACKWARD:
            reverse = true;
            break;
        case LEFT_TO_RIGHT:
            reverse = x1 > x2;
            break;
        case RIGHT_TO_LEFT:
            reverse = x1 < x2;
            break;
        case TOP_TO_BOTTOM:
            reverse = y1 > y2;
            break;
        case BOTTOM_TO_TOP:
            reverse = y1 < y2;
            break;
        case MOST_READABLE:
            reverse = x2 < x1 || y1 > y2;
            break;
        }
        return reverse;
    }

    /**
     * Draws the text character per character to follow the polyline
     * 
     * @param g
     * @param pts
     * @param reverse
     */
    protected void drawFollow(Graphics g, Point2D[] pts, boolean reverse) {
        LinkedList points = new LinkedList();
        if (reverse) {
            for (int i = pts.length - 1; i >= 0; i--)
                points.add(pts[i]);
        } else {
            for (int i = 0; i < pts.length; i++)
                points.add(pts[i]);
        }

        LinkedList polysegment = new LinkedList();
        int l, x1, y1, x2, y2;
        String c;
        Point2D p1, p2;
        double angle;
        for (int i = 0; i < text.length(); i++) {
            c = text.substring(i, i + 1);
            l = metrics.stringWidth(c);
            if (points.size() == 0)
                break;
            LineUtil.retrievePoints(l, points, polysegment);

            p1 = (Point2D) polysegment.getFirst();
            x1 = (int) p1.getX();
            y1 = (int) p1.getY();
            p2 = (Point2D) polysegment.getLast();
            x2 = (int) p2.getX();
            y2 = (int) p2.getY();

            angle = Math.atan2(y2 - y1, x2 - x1);
            drawAngledString(g, c, x1, y1, angle);
        }
    }

    /**
     * Draws the text from a starting point with an angle
     * 
     * @param g
     * @param text
     * @param x
     * @param y
     * @param angle
     */
    public static void drawAngledString(Graphics g, String text, int x, int y,
                                        double angle) {

        Graphics2D g2D = (Graphics2D) g;
        AffineTransform oldAt = g2D.getTransform();
        AffineTransform at = new AffineTransform(oldAt);
        at.rotate(angle, x, y);
        g2D.setTransform(at);
        g2D.drawString(text, x, y);
        g2D.setTransform(oldAt);
    }

    /**
     * Returns the font.
     * 
     * @return Font
     */
    public Font getFont() {
        return font;
    }

    /**
     * Returns the text.
     * 
     * @return String
     */
    public String getText() {
        return text;
    }

    /**
     * Sets the font.
     * 
     * @param font The font to set
     */
    public void setFont(Font font) {
        this.font = font;
        initMetrics();
    }

    /**
     * Sets the text.
     * 
     * @param text The text to set
     */
    public void setText(String text) {
        this.text = text;
        initMetrics();
        setLength(metrics.stringWidth(text));
        setWidth(metrics.getHeight());
    }

    /**
     * Returns the verticalAlignment.
     * 
     * @return int
     */
    public int getVerticalAlignment() {
        return verticalAlignment;
    }

    /**
     * Sets the verticalAlignment.
     * 
     * @param verticalAlignment The verticalAlignment to set (TOP,
     *        CENTER, BASELINE, BOTTOM)
     */
    public void setVerticalAlignment(int verticalAlignment) {
        this.verticalAlignment = verticalAlignment;
    }

}