omdrawingtool.java

OpenMap是一个基于JavaBeansTM的开发工具包。利用OpenMap你就能够快速构建用于访问legacy数据库的应用程序与applets。OpenMap提供了允许用户查看和操作地理空间信息的

// **********************************************************************
//
// <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/tools/drawing/OMDrawingTool.java,v $
// $RCSfile: OMDrawingTool.java,v $
// $Revision: 1.25.2.10 $
// $Date: 2008/01/25 17:44:27 $
// $Author: dietrick $
//
// **********************************************************************

package com.bbn.openmap.tools.drawing;

import java.awt.Component;
import java.awt.Cursor;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.Rectangle;
import java.awt.RenderingHints;
import java.awt.Shape;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseEvent;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.Serializable;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Properties;
import java.util.Set;
import java.util.Vector;

import javax.swing.BorderFactory;
import javax.swing.JComponent;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JSeparator;

import com.bbn.openmap.Environment;
import com.bbn.openmap.I18n;
import com.bbn.openmap.InformationDelegator;
import com.bbn.openmap.MapBean;
import com.bbn.openmap.MapHandler;
import com.bbn.openmap.MouseDelegator;
import com.bbn.openmap.event.MapMouseMode;
import com.bbn.openmap.event.PaintListener;
import com.bbn.openmap.event.ProjectionEvent;
import com.bbn.openmap.event.ProjectionListener;
import com.bbn.openmap.gui.OMToolComponent;
import com.bbn.openmap.gui.WindowSupport;
import com.bbn.openmap.omGraphics.DrawingAttributes;
import com.bbn.openmap.omGraphics.EditableOMGraphic;
import com.bbn.openmap.omGraphics.EditableOMGraphicList;
import com.bbn.openmap.omGraphics.GraphicAttributes;
import com.bbn.openmap.omGraphics.OMAction;
import com.bbn.openmap.omGraphics.OMGraphic;
import com.bbn.openmap.omGraphics.OMGraphicConstants;
import com.bbn.openmap.omGraphics.OMGraphicList;
import com.bbn.openmap.omGraphics.event.EOMGEvent;
import com.bbn.openmap.omGraphics.event.EOMGListener;
import com.bbn.openmap.omGraphics.event.SelectionListener;
import com.bbn.openmap.omGraphics.event.SelectionProvider;
import com.bbn.openmap.omGraphics.event.SelectionSupport;
import com.bbn.openmap.proj.Projection;
import com.bbn.openmap.util.Debug;
import com.bbn.openmap.util.PropUtils;

/**
 * The OMDrawingTool implements the DrawingTool interface, and can be used to
 * adjust the drawing parameters of OMGraphics. It is basically a manager for
 * directing MouseEvents and MouseMotionEvents from a Component to a
 * EditableOMGraphic. The EditableOMGraphic is responsible for interpreting the
 * events and making the adjustments to the OMGraphic it has wrapped within. The
 * OMDrawingTool also tries to keep the presentation of the OMGraphic up to
 * date, by managing the repaints of the Component to include the graphic being
 * modified.
 * <P>
 * 
 * The OMDrawingTool is also a com.bbn.openmap.gui.Tool, which allows it to
 * appear in the OpenMap toolbar. The OMDrawingTool keeps track of whether it is
 * a tool, and appears accordingly:
 * <P>
 * 
 * If the OMDrawingTool is being used as a tool (getUseAsTool() == true), then
 * it will set itself to be visible. If you are putting an OMDrawingTool in the
 * OpenMap application and you want the color/line/graphic options to be visible
 * in the toolbar, use the itTool property for the OMDrawingTool in the
 * properties file. If you are using your own OMDrawingTool, in your
 * EditorLayerTool for instance, you should set useAsTool(true) programmatically
 * to get the visiblity of the tool to appear. There is a property to tell the
 * OMDrawingTool to be visible when it is inactive, and that flag is true by
 * default. You can set that property (visibleWhenInactive) to change this
 * behavior.
 * 
 * If the OMDrawingTool is not being used as a tool, it can be brought up in a
 * window. This window can be brought up with a right click or control-click on
 * the object being edited.
 * <P>
 * 
 * If the OMGraphic being edited doesn't want to have the OMDrawingTool visible,
 * it won't be. Neither the tool nor the option to bring the window up won't be
 * displayed with a right/control click.
 * <P>
 * 
 * The OMDrawingTool uses a behavior mask to give control over how it behaves.
 * You can control if the attribute palette appears, if a popup gui appears by
 * default when the editing is complete, or appear when the alt+mouse key or
 * right mouse key is pressed. You should set this mask if you are not sure
 * about the values that other components may have set on the OMDrawingTool.
 * <P>
 * 
 * The OMDrawingTool uses EditToolLoaders to determine what EditableOMGraphic
 * can be used for a particular class name or OMGraphic type. If a loader for an
 * OMGraphic type is not found, then that OMGraphic type won't be handled, and
 * the tool will react to a create() or edit() call with a null object pointer.
 * If a loader is found, and the OMgraphic can be edited or modified, then the
 * create() or edit() methods will return a pointer to the OMGraphic being
 * modified.
 * <P>
 * 
 * The GUI for the OMDrawingTool is multi-layered. The OMDrawingTool contains a
 * GraphicsAttributes object, which is an extension of the GraphicAttributes
 * object. The GraphicAttributes GUI within the tool lets you change the colors,
 * line width and line dash pattern of the current OMGraphic. The
 * GraphicAttributes conttribution to the GUI is not yet implemented, but will
 * let you change the render type and line type of the OMGraphic. Finally, the
 * EditableOMGraphic is given an opportunity to change and set parameters of the
 * OMGraphic that is knows about - for instance, the EditableOMLine object will
 * soon provide an interface to set arrowheads on the lines, as well as set the
 * amount of arc a line has (it's currently not implemented).
 * <P>
 */
public class OMDrawingTool extends OMToolComponent implements DrawingTool,
        Serializable, PropertyChangeListener, ProjectionListener, EOMGListener,
        PaintListener, SelectionProvider {

    I18n i18n = Environment.getI18n();
    /**
     * A GraphicAttributes object that describes the current coloring parameters
     * for the current graphic.
     */
    protected GraphicAttributes graphicAttributes = GraphicAttributes.getGADefaultClone();

    /** The current graphic being modified. */
    protected EditableOMGraphic currentEditable;
    /**
     * The MouseDelegator to use to get mouse events directed to the
     * DrawingTool.
     */
    protected MouseDelegator mouseDelegator;
    /**
     * A placeholder for the last mouse mode active before the drawing tool took
     * over.
     */
    protected MapMouseMode formerMouseMode = null;
    /**
     * The JComponent the drawing tool is servicing, usually the MapBean.
     */
    protected JComponent canvas;
    /**
     * The objects that know how to create a EditableOMGraphic for a particular
     * class name or OMGraphic.
     */
    protected Hashtable loaders = new Hashtable();
    /**
     * The ordered list of EditToolLoaders, for notification. Preservers order,
     * no duplicates.
     */
    protected Vector rawLoaders = new Vector();
    /**
     * The MouseMode used for the drawing tool.
     */
    protected OMDrawingToolMouseMode dtmm;

    /**
     * The component to notify when the drawing tool is finished.
     */
    protected DrawingToolRequestor requestor = null;
    /** The current projection. */
    protected Projection projection = null;
    /**
     * A support object to handle telling listeners that the drawing tool is in
     * the process of editing an object, hence making it selected.
     */
    protected SelectionSupport selectionSupport = null;

    /**
     * A behavior mask to show the GUI for the OMDrawingTool. Since the
     * OMDrawingTool is a com.bbn.openmap.gui.Tool object, it will only appear
     * on the tool panel if it has been added to it, and if it is being used as
     * a tool.
     */
    public final static int SHOW_GUI_BEHAVIOR_MASK = 1 << 0; // + 1
    /**
     * A behavior mask to add a menu item to the popup that will allow the GUI
     * to appear. If the OMDrawingTool is not being used as a tool and this is
     * set along with USE_POPUP_BEHAVIOR_MASK or ALT_POPUP_BEHAVIOR_MASK, then
     * the OMDrawingTool will appear in a window when the <B>Change Appearance
     * </B> option is selected in the popup menu.
     */
    public final static int GUI_VIA_POPUP_BEHAVIOR_MASK = 1 << 1; // + 2
    /**
     * Flag to tell the OMDrawingTool to display a popup when
     * gesturing/modifications appear to be over. Was the default action of the
     * tool, but was moved to only happening when the ctrl key or right mouse
     * button is pressed. You can force the old behavior by setting this.
     */
    public final static int USE_POPUP_BEHAVIOR_MASK = 1 << 2; // + 4
    /**
     * Allow a GUI popup to appear over the map when the gesturing/modifications
     * appear to be over, and when the ctrl key or right mouse button is
     * pressed.
     */
    public final static int ALT_POPUP_BEHAVIOR_MASK = 1 << 3; // + 8
    /**
     * Set the flag for the behavior that will tell the OMDrawingTool to *NOT*
     * add the OMDrawingToolMouseMode to the MouseDelegator as the active mouse
     * mode when activated. Should be called before create/edit is called, and
     * then you have to make sure that you provide MouseEvents to the
     * OMDrawingToolMouseMode or EditableOMGraphic in order to modify the
     * OMGraphic. Don't call this if you have already started using the tool,
     * the tool won't do anything if anything else is currently being modified.
     */
    public final static int PASSIVE_MOUSE_EVENT_BEHAVIOR_MASK = 1 << 4; // + 16
    /**
     * This behavior is used internally, when the OMDrawingTool should be told
     * to clean up as soon as it is safe.
     */
    public final static int DEACTIVATE_ASAP_BEHAVIOR_MASK = 1 << 5; // + 32
    /**
     * A convenience value that tells the OMDrawingTool to show the GUI if it is
     * a tool, or to only display the popup with the ctrl key or right mouse
     * button if it isn't. A combination of SHOW_GUI, GUI_VIA_POPUP and
     * ALT_POPUP.
     */
    public final static int DEFAULT_BEHAVIOR_MASK = 11;
    /**
     * A convenience value that tells the OMDrawingTool to not show the GUI, but
     * show the popup with the alt key, and the popup has the ability to delete
     * the OMGraphic. A combination of GUI_VIA_POPUP and ALT_POPUP.
     */
    public final static int QUICK_CHANGE_BEHAVIOR_MASK = 10;

    /**
     * A integer that is looked at, bitwise, to determine different behaviors.
     */
    protected int behaviorMask = DEFAULT_BEHAVIOR_MASK;
    /**
     * Used for property change notifications.
     */
    public final static String LoadersProperty = "OMDrawingTool.loaders";

    /**
     * Debug flag turned on when <B>drawingtool </B> debug flag enabled.
     */
    protected boolean DEBUG = false;

    /**
     * A handle to the InformationDelegator to use for status messages.
     */
    protected InformationDelegator informationDelegator = null;

    /**
     * A Vector of Classes that can be handled by the OMDrawingTool. Constructed
     * the first time canEdit() is called after an EditToolLoader is added or
     * removed.
     */
    protected Vector possibleEditableClasses = null;

    /**
     * Just a helper flag to reduce work caused by unnecessary deactivate calls.
     * Set internally in activate() and deactivate().
     */
    protected boolean activated = false;

    /**
     * Tell the drawing tool to be invisible when it is inactive. True by
     * default.
     */
    protected boolean visibleWhenInactive = true;

    /**
     * The property, visibleWhenIactive, to set to false if you want that
     * behavior.
     */
    public final static String VisibleWhenInactiveProperty = "visibleWhenInactive";

    /**
     * The property list defining behavior mask values that should be set.
     */
    public final static String BehaviorProperty = "behavior";

    /**
     * Flag to tell tool to reset the GUI when it is deactivated. The only time
     * you would want this to be false (true is default) is when you are
     * creating many objects of the same type, and don't want the gui to keep
     * going back and forth between the default and special settings. Usually
     * set to in the drawingComplete method of an EditorTool. Reset to true when
     * showPalette is called.
     */
    protected boolean resetGUIWhenDeactivated = true;

    /**
     * Create a OpenMap Drawing Tool.
     */
    public OMDrawingTool() {
        super();
        setBorder(BorderFactory.createEmptyBorder());
        DEBUG = Debug.debugging("drawingtool");
        selectionSupport = new SelectionSupport(this);
        setAttributes(new GraphicAttributes());
        setMouseMode(createMouseMode());

        // Shouldn't assume that the drawing tool is a tool. This can
        // be set in the properties if it should be. Otherwise, the
        // default action is to appear on a right click called from
        // the GUI.
        setUseAsTool(false);
    }

    /**
     * Create the mouse mode used with the drawing tool. Called in the default
     * empty constructor, returns a OMDrawingToolMouseMode by default.
     */
    protected OMDrawingToolMouseMode createMouseMode() {
        return new OMDrawingToolMouseMode(this);
    }

    /**
     * Create a new OMGraphic, encased in a new EditableOMGraphic that can
     * modify it. If a loader cannot be found that can handle a graphic with the
     * given classname, this method will return a null object. If you aren't
     * sure of the behavior mask set in the tool, and you want a particular
     * behavior, set it before calling this method.
     * 
     * @param classname the classname of the graphic to create.
     * @param requestor the Component that is requesting the OMGraphic. The
     *        requestor gets notified when the user is finished with the
     *        DrawingTool and the graphic is ready.
     * @return OMGraphic of the classname given, null if the DrawingTool can't