editableompoly.java

来自「OpenMap是一个基于JavaBeansTM的开发工具包。利用OpenMap你」· Java 代码 · 共 1,371 行 · 第 1/4 页

// **********************************************************************
// 
// <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/omGraphics/EditableOMPoly.java,v $
// $RCSfile: EditableOMPoly.java,v $
// $Revision: 1.9.2.6 $
// $Date: 2008/01/29 02:21:01 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.omGraphics;

import java.awt.Component;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.net.URL;
import java.util.ArrayList;
import java.util.Iterator;

import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JMenu;
import javax.swing.JToggleButton;
import javax.swing.JToolBar;

import com.bbn.openmap.LatLonPoint;
import com.bbn.openmap.gui.GridBagToolBar;
import com.bbn.openmap.layer.util.stateMachine.State;
import com.bbn.openmap.omGraphics.editable.GraphicEditState;
import com.bbn.openmap.omGraphics.editable.GraphicSelectedState;
import com.bbn.openmap.omGraphics.editable.PolyAddNodeState;
import com.bbn.openmap.omGraphics.editable.PolyDeleteNodeState;
import com.bbn.openmap.omGraphics.editable.PolyStateMachine;
import com.bbn.openmap.omGraphics.editable.PolyUndefinedState;
import com.bbn.openmap.proj.Projection;
import com.bbn.openmap.util.Debug;

/**
 * The EditableOMPoly encompasses an OMPoly, providing methods for modifying or
 * creating it.
 */
public class EditableOMPoly extends EditableOMAbstractLine {

    protected ArrayList polyGrabPoints;
    protected OffsetGrabPoint gpo; // offset
    protected OffsetGrabPoint gpm; // for grabbing the poly and
    // moving
    // it.

    protected OMPoly poly;
    /**
     * Whether the poly is a polygon, as opposed to a polyline. If the poly
     * color is not clear (OMColor.clear) then it will be a polygon. If it is
     * clear, then it can be set as a polygon - it's otherwise assumed to be a
     * polyline.
     */
    protected boolean manualEnclosed = false;

    // We'll have to handle this differently...
    public static int OFFSET_POINT_INDEX = -1;

    /**
     * Create the EditableOMPoly, setting the state machine to create the poly
     * off of the gestures.
     */
    public EditableOMPoly() {
        createGraphic(null);
    }

    /**
     * Create an EditableOMPoly with the polyType and renderType parameters in
     * the GraphicAttributes object.
     */
    public EditableOMPoly(GraphicAttributes ga) {
        createGraphic(ga);
    }

    /**
     * Create the EditableOMPoly with an OMPoly already defined, ready for
     * editing.
     * 
     * @param omp OMPoly that should be edited.
     */
    public EditableOMPoly(OMPoly omp) {
        setGraphic(omp);
    }

    /**
     * Create and initialize the state machine that interprets the
     * 
     * modifying gestures/commands, as well as ititialize the grab points. Also
     * allocates the grab point array needed by the EditableOMPoly.
     */
    public void init() {
        Debug.message("eomg", "EditableOMPoly.init()");
        setStateMachine(new PolyStateMachine(this));
        gPoints = new GrabPoint[1];
    }

    /**
     * Set the graphic within the state machine. If the graphic is null, then
     * one shall be created, and located off screen until the gestures driving
     * the state machine place it on the map.
     */
    public void setGraphic(OMGraphic graphic) {
        init();
        if (graphic instanceof OMPoly) {
            poly = (OMPoly) graphic;
            poly.setDoShapes(true);
            stateMachine.setSelected();
            setGrabPoints(poly);
        } else {
            createGraphic(null);
        }
    }

    /**
     * Method checks if the polygon should be enclosed, and then adds an
     * addition point to the end of the polygon, setting the end point on top of
     * the beginning point. The two points are OffsetGrabPoints that are tied to
     * each other's position.
     */
    public boolean evaluateEnclosed() {
        deletePoint();
        boolean enclosed = false;

        if (isEnclosed()) {
            enclose(true);
            enclosed = true;
        }
        return enclosed;
    }

    /**
     * Method connects the last point to the first point. Make sure they are
     * both OffsetGrabPoints. Return true if the points cover the same pixel and
     * if they were successfully joined.
     */
    protected boolean syncEnclosed() {
        try {
            OffsetGrabPoint gb0 = (OffsetGrabPoint) polyGrabPoints.get(0);
            OffsetGrabPoint ogb = (OffsetGrabPoint) polyGrabPoints.get(polyGrabPoints.size() - 1);

            // Check to see if they are over the same point.
            if (gb0.getX() == ogb.getX() && gb0.getY() == ogb.getY()) {

                // Cross connect them...
                gb0.addGrabPoint(ogb);
                ogb.addGrabPoint(gb0);
                return true;
            }
        } catch (ClassCastException cce) {
        } catch (IndexOutOfBoundsException ioobe) {
        }
        return false;
    }

    /**
     * Method disconnects the last point from the first point. Make sure they
     * are both OffsetGrabPoints.
     */
    protected boolean unsyncEnclosed() {
        try {
            OffsetGrabPoint gb0 = (OffsetGrabPoint) polyGrabPoints.get(0);
            OffsetGrabPoint ogb = (OffsetGrabPoint) polyGrabPoints.get(polyGrabPoints.size() - 1);

            // disconnect them...
            if (gb0.getX() == ogb.getX() && gb0.getY() == ogb.getY()) {
                gb0.removeGrabPoint(ogb);
                ogb.removeGrabPoint(gb0);
                return true;
            }
        } catch (ClassCastException cce) {
        } catch (ArrayIndexOutOfBoundsException aioobe) {
        }
        return false;
    }

    public void enclose(boolean e) {
        setEnclosed(e);

        if (polyGrabPoints == null) {
            return;
        }

        OffsetGrabPoint gb0 = (OffsetGrabPoint) polyGrabPoints.get(0);
        OffsetGrabPoint ogb;

        if (e) {
            // If they should be enclosed...
            if (!syncEnclosed()) {
                // And they are not already, then add a point, joined
                // to the beginning.
                ogb = new OffsetGrabPoint(gb0.getX(), gb0.getY());

                // Add the new point to end of the poly
                addPoint(ogb);
                syncEnclosed();
                repaint();
            } // Else nothing to do...
        } else {
            // They shouldn't be hooked up, so check to see if they
            // are, and disconnect if necessary.
            if (unsyncEnclosed()) {
                deletePoint(); // Delete attached duplicate point
                repaint();
            } // else nothing to do.
        }
    }

    /**
     * Set the flag to make the polygon enclosed, which automatically connects
     * the last point with the first point.
     */
    public void setEnclosed(boolean set) {
        manualEnclosed = set;
    }

    /**
     * Returns whether the graphic will be a polygon, instead of a polyline.
     */
    public boolean isEnclosed() {
        return manualEnclosed;
    }

    /**
     * Create and set the graphic within the state machine. The
     * GraphicAttributes describe the type of poly to create.
     */
    public void createGraphic(GraphicAttributes ga) {
        init();
        stateMachine.setUndefined();
        int renderType = OMGraphic.RENDERTYPE_LATLON;
        int lineType = OMGraphic.LINETYPE_GREATCIRCLE;

        if (ga != null) {
            renderType = ga.getRenderType();
            lineType = ga.getLineType();
        }

        if (Debug.debugging("eomg")) {
            Debug.output("EditableOMPoly.createGraphic(): rendertype = "
                    + renderType);
        }

        if (lineType == OMGraphic.LINETYPE_UNKNOWN) {
            lineType = OMGraphic.LINETYPE_GREATCIRCLE;
            ga.setLineType(OMGraphic.LINETYPE_GREATCIRCLE);
        }

        this.poly = (OMPoly) createGraphic(renderType, lineType);

        if (ga != null) {
            ga.setRenderType(poly.getRenderType());
            ga.setTo(poly, true);
        }
    }

    /**
     * Extendable method to create specific subclasses of OMPolys.
     */
    public OMGraphic createGraphic(int renderType, int lineType) {
        OMGraphic g = null;
        switch (renderType) {
        case (OMGraphic.RENDERTYPE_LATLON):
            g = new OMPoly(new float[0], OMGraphic.RADIANS, lineType);
            break;
        case (OMGraphic.RENDERTYPE_OFFSET):
            g = new OMPoly(90f, -180f, new int[0], OMPoly.COORDMODE_ORIGIN);
            break;
        default:
            g = new OMPoly(new int[0]);
        }
        ((OMPoly) g).setDoShapes(true);
        return g;
    }

    /**
     * Get the OMGraphic being created/modified by the EditableOMPoly.
     */
    public OMGraphic getGraphic() {
        return poly;
    }

    /**
     * Attach to the Moving OffsetGrabPoint so if it moves, it will move this
     * EditableOMGraphic with it. EditableOMGraphic version doesn't do anything,
     * each subclass has to decide which of its OffsetGrabPoints should be
     * attached to it.
     */
    public void attachToMovingGrabPoint(OffsetGrabPoint gp) {
        gp.addGrabPoint(gpo);
    }

    /**
     * Detach from a Moving OffsetGrabPoint. The EditableOMGraphic version
     * doesn't do anything, each subclass should remove whatever GrabPoint it
     * would have attached to an OffsetGrabPoint.
     */
    public void detachFromMovingGrabPoint(OffsetGrabPoint gp) {
        gp.removeGrabPoint(gpo);
    }

    /**
     * Set the GrabPoint that is in the middle of being modified, as a result of
     * a mouseDragged event, or other selection process.
     */
    public void setMovingPoint(GrabPoint gp) {
        super.setMovingPoint(gp);
        gpm = null;
    }

    /**
     * Given a MouseEvent, find a GrabPoint that it is touching, and set the
     * moving point to that GrabPoint. Called when a MouseEvent happens, and you
     * want to find out if a GrabPoint should be used to make modifications to
     * the graphic or its position.
     * 
     * @param e MouseEvent
     * @return GrabPoint that is touched by the MouseEvent, null if none are.
     */
    public GrabPoint getMovingPoint(MouseEvent e) {
        GrabPoint gb = super.getMovingPoint(e);

        // Since there may be an extra point enclosing the polygon, we
        // want to make sure that the start of the polygon is
        // returned, instead of the duplicate ending point.
        int lastPointIndex = polyGrabPoints.size() - 1;