defaultoverviewmousemode.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/DefaultOverviewMouseMode.java,v $
// $RCSfile: DefaultOverviewMouseMode.java,v $
// $Revision: 1.2.2.1 $
// $Date: 2004/10/14 18:26:45 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.event;

import com.bbn.openmap.gui.OverviewMapHandler;
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;

import java.awt.event.*;
import java.awt.Point;

/**
 * A MouseMode that handles drawing a box, or clicking on a point, but
 * directs the updates to the ControlledMapSupport of the overview map
 * handler, instead of the overview MapBean, which would have been the
 * normal behavior.
 */
public class DefaultOverviewMouseMode extends NavMouseMode2 {

    OverviewMapHandler overviewMapHandler;

    /**
     * Construct a OverviewMouseMode. Sets the ID of the mode to the
     * modeID, the consume mode to true, and the cursor to the
     * crosshair.
     */
    public DefaultOverviewMouseMode(OverviewMapHandler omh) {
        super(true);
        overviewMapHandler = omh;
    }

    /**
     * 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 source 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")) {
            System.out.println(getID()
                    + "|DefaultOverviewMouseMode.mouseReleased()");
        }
        Object obj = e.getSource();
        if (!mouseSupport.fireMapMouseReleased(e)) {
            if (!(obj instanceof MapBean) || !autoZoom || point1 == null)
                return;
            MapBean map = (MapBean) obj;
            Projection projection = map.getProjection();

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

                // Dont 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());
                        overviewMapHandler.getControlledMapListeners()
                                .setCenter(llp);
                    }
                    return;
                }

                // Figure out the new scale
                com.bbn.openmap.LatLonPoint ll1 = projection.inverse(point1);
                com.bbn.openmap.LatLonPoint ll2 = projection.inverse(point2);

                float deltaDegrees;
                int deltaPix;
                dx = Math.abs(point2.x - point1.x);
                dy = Math.abs(point2.y - point1.y);

                if (dx < dy) {
                    float dlat = Math.abs(ll1.getLatitude() - ll2.getLatitude());
                    deltaDegrees = dlat * 2;
                    deltaPix = overviewMapHandler.getSourceMap()
                            .getProjection()
                            .getHeight();
                } else {
                    float dlon;
                    float lat1, lon1, lon2;

                    // point1 is to the right of point2. switch the
                    // LatLonPoints so that ll1 is west (left) of ll2.
                    if (point1.x > point2.x) {
                        lat1 = ll1.getLatitude();
                        lon1 = ll1.getLongitude();
                        ll1.setLatLon(ll2);
                        ll2.setLatLon(lat1, lon1);
                    }

                    lon1 = ll1.getLongitude();
                    lon2 = ll2.getLongitude();

                    // allow for crossing dateline
                    if (lon1 > lon2) {
                        dlon = (180 - lon1) + (180 + lon2);
                    } else {
                        dlon = lon2 - lon1;
                    }

                    deltaDegrees = dlon * 2;
                    deltaPix = overviewMapHandler.getSourceMap()
                            .getProjection()
                            .getWidth();
                }

                float pixPerDegree = ((Proj) projection).getPlanetPixelCircumference() / 360;
                float newScale = pixPerDegree / (deltaPix / deltaDegrees);

                // Figure out the center of the rectangle
                com.bbn.openmap.LatLonPoint center = projection.inverse(point1.x,
                        point1.y);

                // Set the parameters of the projection and then set
                // the projection of the map. This way we save having
                // the MapBean fire two ProjectionEvents.
                overviewMapHandler.getControlledMapListeners()
                        .setScale(newScale);
                overviewMapHandler.getControlledMapListeners()
                        .setCenter(center);
            }
            // reset the points
            point1 = null;
            point2 = null;
        }
    }

    /**
     * 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 = overviewMapHandler.getSourceMap().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;
    }
}