navmousemode.java

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

// **********************************************************************
// 
// <copyright>
// 
//  BBN Technologies
//  10 Moulton Street
//  Cambridge, MA 02138
//  [phone]
// 
//  Copyright (C) BBNT Solutions LLC. All rights reserved.
// 
// </copyright>
// **********************************************************************
// 
// $Source: /cvs/distapps/openmap/src/openmap/com/bbn/openmap/event/NavMouseMode.java,v $
// $RCSfile: NavMouseMode.java,v $
// $Revision: 1.5.2.4 $
// $Date: 2005/08/09 17:38:50 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.event;

import java.awt.Cursor;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.event.MouseEvent;

import com.bbn.openmap.LatLonPoint;
import com.bbn.openmap.MapBean;
import com.bbn.openmap.proj.Proj;
import com.bbn.openmap.proj.Projection;
import com.bbn.openmap.util.Debug;

/**
 * The Navigation Mouse Mode interprets mouse clicks and mouse drags
 * to recenter and rescale the map. The map is centered on the
 * location where a click occurs. If a box is drawn by clicking down
 * and dragging the mouse, the map is centered on the dot in the
 * center of the box, and the scale is adjusted so the screen fills
 * the area designated by the box.
 * <p>
 * You MUST add this MouseMode as a ProjectionListener to the MapBean
 * to get it to work. If you use a MouseDelegator with the bean, it
 * will take care of that for you.
 */
public class NavMouseMode extends CoordMouseMode {

    /**
     * Mouse Mode identifier, which is "Navigation".
     */
    public final static transient String modeID = "Navigation";

    protected Point point1, point2;
    protected boolean autoZoom = false;

    /**
     * Construct a NavMouseMode. Sets the ID of the mode to the
     * modeID, the consume mode to true, and the cursor to the
     * crosshair.
     */
    public NavMouseMode() {
        this(true);
    }

    /**
     * Construct a NavMouseMode. Lets you set the consume mode. If the
     * events are consumed, then a MouseEvent is sent only to the
     * first MapMouseListener that successfully processes the event.
     * If they are not consumed, then all of the listeners get a
     * chance to act on the event.
     * 
     * @param shouldConsumeEvents the mode setting.
     */
    public NavMouseMode(boolean shouldConsumeEvents) {
        super(modeID, shouldConsumeEvents);
        // override the default cursor
        setModeCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
    }

    /**
     * Handle a mousePressed MouseListener event. Erases the old
     * navigation rectangle if there is one, and then keeps the press
     * point for reference later.
     * 
     * @param e MouseEvent to be handled
     */
    public void mousePressed(MouseEvent e) {
        if (Debug.debugging("mousemode")) {
            Debug.output(getID() + "|NavMouseMode.mousePressed()");
        }
        e.getComponent().requestFocus();

        if (!mouseSupport.fireMapMousePressed(e)
                && e.getSource() instanceof MapBean) {
            // set the new first point
            point1 = e.getPoint();
            // ensure the second point isn't set.
            point2 = null;
            autoZoom = true;
        }
    }

    /**
     * Handle a mouseReleased MouseListener event. If there was no
     * drag events, or if there was only a small amount of dragging
     * between the occurence of the mousePressed and this event, then
     * recenter the map. Otherwise we get the second corner of the
     * navigation rectangle and try to figure out the best scale and
     * location to zoom in to based on that rectangle.
     * 
     * @param e MouseEvent to be handled
     */
    public void mouseReleased(MouseEvent e) {
        if (Debug.debugging("mousemode")) {
            Debug.output(getID() + "|NavMouseMode.mouseReleased()");
        }
        Object obj = e.getSource();

        mouseSupport.fireMapMouseReleased(e);

        if (!(obj instanceof MapBean) || !autoZoom || point1 == null)
            return;

        MapBean map = (MapBean) obj;
        Projection projection = map.getProjection();
        Proj p = (Proj) projection;

        synchronized (this) {
            point2 = e.getPoint();
            int dx = Math.abs(point2.x - point1.x);
            int dy = Math.abs(point2.y - point1.y);

            // Don't bother redrawing if the rectangle is too small
            if ((dx < 5) || (dy < 5)) {
                // clean up the rectangle, since point2 has the old
                // value.
                paintRectangle(map, point1, point2);

                // If rectangle is too small in both x and y then
                // recenter the map
                if ((dx < 5) && (dy < 5)) {
                    LatLonPoint llp = projection.inverse(e.getPoint());

                    boolean shift = e.isShiftDown();
                    boolean control = e.isControlDown();

                    if (control) {
                        if (shift) {
                            p.setScale(p.getScale() * 2.0f);
                        } else {
                            p.setScale(p.getScale() / 2.0f);
                        }
                    }

                    // reset the points here so the point doesn't get
                    // rendered on the repaint.
                    point1 = null;
                    point2 = null;

                    p.setCenter(llp);
                    map.setProjection(p);
                }
                return;
            }

            // Figure out the new scale
            float newScale = com.bbn.openmap.proj.ProjMath.getScale(point1,
                    point2,
                    projection);

            // Figure out the center of the rectangle
            int centerx = Math.min(point1.x, point2.x) + dx / 2;
            int centery = Math.min(point1.y, point2.y) + dy / 2;
            com.bbn.openmap.LatLonPoint center = projection.inverse(centerx,
                    centery);

            // Fire events on main map to change view to match rect1
            //    Debug.output("point1: " +point1);
            //    Debug.output("point2: " +point2);
            //        Debug.output("Centerx: " +centerx +
            //             " Centery: " + centery);
            //          Debug.output("New Scale: " + newScale);
            //          Debug.output("New Center: " +center);

            // Set the parameters of the projection and then set
            // the projection of the map. This way we save having
            // the MapBean fire two ProjectionEvents.
            p.setScale(newScale);
            p.setCenter(center);

            // reset the points here so the point doesn't get rendered
            // on the repaint.
            point1 = null;
            point2 = null;

            map.setProjection(p);
        }
    }

    /**
     * Handle a mouseEntered MouseListener event. The boolean autoZoom
     * is set to true, which will make the delegate ask the map to
     * zoom in to a box that is drawn.
     * 
     * @param e MouseEvent to be handled
     */
    public void mouseEntered(MouseEvent e) {
        if (Debug.debugging("mousemodedetail")) {
            Debug.output(getID() + "|NavMouseMode.mouseEntered()");
        }
        super.mouseEntered(e);
        autoZoom = true;
    }

    /**
     * Handle a mouseExited MouseListener event. The boolean autoZoom
     * is set to false, which will cause the delegate to NOT ask the
     * map to zoom in on a box. If a box is being drawn, it will be
     * erased. The point1 is kept in case the mouse comes back on the
     * screen with the button still down. Then, a new box will be
     * drawn with the original mouse press position.
     * 
     * @param e MouseEvent to be handled
     */
    public void mouseExited(MouseEvent e) {
        if (Debug.debugging("mousemodedetail")) {
            Debug.output(getID() + "|NavMouseMode.mouseExited()");
        }

        super.mouseExited(e);

        if (e.getSource() instanceof MapBean) {
            // don't zoom in, because the mouse is off the window.
            autoZoom = false;
            // clean up the last box drawn
            paintRectangle((MapBean) e.getSource(), point1, point2);
            // set the second point to null so that a new box will be
            // drawn if the mouse comes back, and the box will use the
            // old
            // starting point, if the mouse button is still down.
            point2 = null;

        }
    }

    // Mouse Motion Listener events
    ///////////////////////////////

    /**
     * Handle a mouseDragged MouseMotionListener event. A rectangle is
     * drawn from the mousePressed point, since I'm assuming that I'm
     * drawing a box to zoom the map to. If a previous box was drawn,
     * it is erased.
     * 
     * @param e MouseEvent to be handled
     */
    public void mouseDragged(MouseEvent e) {
        if (Debug.debugging("mousemodedetail")) {
            Debug.output(getID() + "|NavMouseMode.mouseDragged()");
        }

        super.mouseDragged(e);

        if (e.getSource() instanceof MapBean) {
            if (!autoZoom)
                return;

            // clean up the old rectangle, since point2 has the old
            // value.
            paintRectangle((MapBean) e.getSource(), point1, point2);
            // paint new rectangle
            //          point2 = e.getPoint();
            point2 = getRatioPoint((MapBean) e.getSource(),
                    point1,
                    e.getPoint());
            paintRectangle((MapBean) e.getSource(), point1, point2);
        }
    }

    /**
     * Given a MapBean, which provides the projection, and the
     * starting point of a box (pt1), look at pt2 to see if it
     * represents the ratio of the projection map size. If it doesn't,
     * provide a point that does.
     */
    protected Point getRatioPoint(MapBean map, Point pt1, Point pt2) {
        Projection proj = map.getProjection();
        float mapRatio = (float) proj.getHeight() / (float) proj.getWidth();

        float boxHeight = (float) (pt1.y - pt2.y);
        float boxWidth = (float) (pt1.x - pt2.x);
        float boxRatio = Math.abs(boxHeight / boxWidth);
        int isNegative = -1;
        if (boxRatio > mapRatio) {
            // box is too tall, adjust boxHeight
            if (boxHeight < 0)
                isNegative = 1;
            boxHeight = Math.abs(mapRatio * boxWidth);
            pt2.y = pt1.y + (isNegative * (int) boxHeight);

        } else if (boxRatio < mapRatio) {
            // box is too wide, adjust boxWidth
            if (boxWidth < 0)
                isNegative = 1;
            boxWidth = Math.abs(boxHeight / mapRatio);
            pt2.x = pt1.x + (isNegative * (int) boxWidth);
        }
        return pt2;
    }

    /**
     * Draws or erases boxes between two screen pixel points. The
     * graphics from the map is set to XOR mode, and this method uses
     * two colors to make the box disappear if on has been drawn at
     * these coordinates, and the box to appear if it hasn't.
     * 
     * @param pt1 one corner of the box to drawn, in window pixel
     *        coordinates.
     * @param pt2 the opposite corner of the box.
     */
    protected void paintRectangle(MapBean map, Point pt1, Point pt2) {
        if (map != null) {
            paintRectangle(map.getGraphics(), pt1, pt2);
        }
    }

    /**
     * Draws or erases boxes between two screen pixel points. The
     * graphics from the map is set to XOR mode, and this method uses
     * two colors to make the box disappear if on has been drawn at
     * these coordinates, and the box to appear if it hasn't.
     * 
     * @param pt1 one corner of the box to drawn, in window pixel
     *        coordinates.
     * @param pt2 the opposite corner of the box.
     */
    protected void paintRectangle(Graphics g, Point pt1, Point pt2) {
        g.setXORMode(java.awt.Color.lightGray);
        g.setColor(java.awt.Color.darkGray);

        if (pt1 != null && pt2 != null) {
            int width = Math.abs(pt2.x - pt1.x);
            int height = Math.abs(pt2.y - pt1.y);

            if (width == 0)
                width++;
            if (height == 0)
                height++;

            g.drawRect(pt1.x < pt2.x ? pt1.x : pt2.x, pt1.y < pt2.y ? pt1.y
                    : pt2.y, width, height);
            g.drawRect(pt1.x < pt2.x ? pt1.x + (pt2.x - pt1.x) / 2 - 1 : pt2.x
                    + (pt1.x - pt2.x) / 2 - 1,
                    pt1.y < pt2.y ? pt1.y + (pt2.y - pt1.y) / 2 - 1 : pt2.y
                            + (pt1.y - pt2.y) / 2 - 1,
                    2,
                    2);
        }
    }

    /**
     * Called by the MapBean when it repaints, to let the MouseMode
     * know when to update itself on the map. PaintListener interface.
     */
    public void listenerPaint(java.awt.Graphics g) {
        // will be properly rejected of point1, point2 == null
        paintRectangle(g, point1, point2);
    }

}