layer.java

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

                + AutoPaletteProperty, autoPalette);

        setMinScale(PropUtils.floatFromProperties(props, realPrefix
                + MinScaleProperty, getMinScale()));
        setMaxScale(PropUtils.floatFromProperties(props, realPrefix
                + MaxScaleProperty, getMaxScale()));
    }

    public void setName(String name) {
        super.setName(name);

        BeanContext bc = getBeanContext();
        if (bc != null && bc instanceof MapHandler) {
            LayerHandler lh = (LayerHandler) ((MapHandler) bc).get("com.bbn.openmap.LayerHandler");

            if (lh != null) {
                lh.setLayers();
            }
        }
    }

    /**
     * PropertyConsumer method, to fill in a Properties object, reflecting the
     * current values of the layer. If the layer has a propertyPrefix set, the
     * property keys should have that prefix plus a separating '.' prepended to
     * each propery key it uses for configuration.
     * 
     * @param props a Properties object to load the PropertyConsumer properties
     *        into. If props equals null, then a new Properties object should be
     *        created.
     * @return Properties object containing PropertyConsumer property values. If
     *         getList was not null, this should equal getList. Otherwise, it
     *         should be the Properties object created by the PropertyConsumer.
     */
    public Properties getProperties(Properties props) {
        if (props == null) {
            props = new Properties();
        }

        String prefix = PropUtils.getScopedPropertyPrefix(propertyPrefix);
        props.put(prefix + "class", this.getClass().getName());

        String prettyName = getName();
        if (prettyName != null) {
            props.put(prefix + PrettyNameProperty, prettyName);
        }

        props.put(prefix + AutoPaletteProperty,
                new Boolean(autoPalette).toString());
        props.put(prefix + AddAsBackgroundProperty,
                new Boolean(addAsBackground).toString());
        props.put(prefix + RemovableProperty, new Boolean(removable).toString());
        props.put(prefix + AddToBeanContextProperty,
                new Boolean(addToBeanContext).toString());

        if (getMinScale() != Float.MIN_VALUE) {
            props.put(prefix + MinScaleProperty, Float.toString(getMinScale()));
        }
        if (getMaxScale() != Float.MAX_VALUE) {
            props.put(prefix + MaxScaleProperty, Float.toString(getMaxScale()));
        }

        return props;
    }

    /**
     * Method to fill in a Properties object with values reflecting the
     * properties able to be set on this PropertyConsumer. The key for each
     * property should be the raw property name (without a prefix) with a value
     * that is a String that describes what the property key represents, along
     * with any other information about the property that would be helpful
     * (range, default value, etc.). For Layer, this method should at least
     * return the 'prettyName' property.
     * 
     * @param list a Properties object to load the PropertyConsumer properties
     *        into. If getList equals null, then a new Properties object should
     *        be created.
     * @return Properties object containing PropertyConsumer property values. If
     *         getList was not null, this should equal getList. Otherwise, it
     *         should be the Properties object created by the PropertyConsumer.
     */
    public Properties getPropertyInfo(Properties list) {
        if (list == null) {
            list = new Properties();
        }

        list.put("class", "Class Name used for Layer.");
        list.put("class.editor",
                "com.bbn.openmap.util.propertyEditor.NonEditablePropertyEditor");

        String internString = i18n.get(Layer.class,
                PrettyNameProperty,
                I18n.TOOLTIP,
                "Presentable name for Layer");
        list.put(PrettyNameProperty, internString);
        internString = i18n.get(Layer.class, PrettyNameProperty, "Layer Name");
        list.put(PrettyNameProperty + LabelEditorProperty, internString);
        list.put(PrettyNameProperty + ScopedEditorProperty,
                "com.bbn.openmap.util.propertyEditor.NonEditablePropertyEditor");

        internString = i18n.get(Layer.class,
                AutoPaletteProperty,
                I18n.TOOLTIP,
                "Flag to automatically display palette when properties are set");
        list.put(AutoPaletteProperty, internString);
        internString = i18n.get(Layer.class,
                AutoPaletteProperty,
                "Open Palette At Start");
        list.put(AutoPaletteProperty + LabelEditorProperty, internString);
        list.put(AutoPaletteProperty + ScopedEditorProperty,
                "com.bbn.openmap.util.propertyEditor.YesNoPropertyEditor");

        internString = i18n.get(Layer.class,
                AddAsBackgroundProperty,
                I18n.TOOLTIP,
                "Flag to use the layer as a background layer");
        list.put(AddAsBackgroundProperty, internString);
        internString = i18n.get(Layer.class,
                AddAsBackgroundProperty,
                "Background");
        list.put(AddAsBackgroundProperty + LabelEditorProperty, internString);
        list.put(AddAsBackgroundProperty + ScopedEditorProperty,
                "com.bbn.openmap.util.propertyEditor.YesNoPropertyEditor");

        internString = i18n.get(Layer.class,
                RemovableProperty,
                I18n.TOOLTIP,
                "Flag to allow layer to be deleted.");
        list.put(RemovableProperty, internString);
        internString = i18n.get(Layer.class, RemovableProperty, "Removable");
        list.put(RemovableProperty + LabelEditorProperty, internString);
        list.put(RemovableProperty + ScopedEditorProperty,
                "com.bbn.openmap.util.propertyEditor.YesNoPropertyEditor");

        internString = i18n.get(Layer.class,
                AddToBeanContextProperty,
                I18n.TOOLTIP,
                "Flag to give the layer access to all of the other application components.");
        list.put(AddToBeanContextProperty, internString);
        internString = i18n.get(Layer.class,
                AddToBeanContextProperty,
                "Add to MapHandler");
        list.put(AddToBeanContextProperty + LabelEditorProperty, internString);
        list.put(AddToBeanContextProperty + ScopedEditorProperty,
                "com.bbn.openmap.util.propertyEditor.YesNoPropertyEditor");

        internString = i18n.get(Layer.class,
                MinScaleProperty,
                I18n.TOOLTIP,
                "Minimum projection scale value that the layer will respond to.");
        list.put(MinScaleProperty, internString);
        internString = i18n.get(Layer.class,
                MinScaleProperty,
                "Minimum Scale Value");
        list.put(MinScaleProperty + LabelEditorProperty, internString);

        internString = i18n.get(Layer.class,
                MaxScaleProperty,
                I18n.TOOLTIP,
                "Maximum projection scale value that the layer will respond to.");
        list.put(MaxScaleProperty, internString);
        internString = i18n.get(Layer.class,
                MaxScaleProperty,
                "Maximum Scale Value");
        list.put(MaxScaleProperty + LabelEditorProperty, internString);

        return list;
    }

    /**
     * Set the property key prefix that should be used by the PropertyConsumer.
     * The prefix, along with a '.', should be prepended to the property keys
     * known by the PropertyConsumer.
     * 
     * @param prefix the prefix String.
     */
    public void setPropertyPrefix(String prefix) {
        propertyPrefix = prefix;
    }

    /**
     * Get the property key prefix that is being used to prepend to the property
     * keys for Properties lookups.
     * 
     * @return the property prefix for the layer
     */
    public String getPropertyPrefix() {
        return propertyPrefix;
    }

    /**
     * Set the projection the layer should use for calculations. You probably
     * don't need this if you are wondering if you do. Call
     * setProjection(projEvent) instead.
     */
    public void setProjection(Projection proj) {
        projection = proj;
    }

    /**
     * This method lets you take the ProjectionEvent received from the MapBean,
     * and lets you know if you should do something with it. MUST to be called
     * in the projectionChanged() method of your layer, if you want to refer to
     * the projection later. If this methods returns null, you probably just
     * want to call repaint() if your layer.paint() method is ready to paint
     * what it should.
     * 
     * @param projEvent the ProjectionEvent from the ProjectionListener method.
     * @return The new Projection if it is different from the one we already
     *         have, null if is the same as the current one.
     */
    public Projection setProjection(ProjectionEvent projEvent) {
        Projection newProjection = projEvent.getProjection();

        if (!newProjection.equals(getProjection())) {
            Projection clone = newProjection.makeClone();
            setProjection(clone);
            return clone;
        } else {
            return null;
        }
    }

    /**
     * Get the latest projection.
     */
    public Projection getProjection() {
        return projection;
    }

    /**
     * Returns the MapMouseListener object that handles the mouse events. This
     * method is IGNORED in this class: it returns null. Derived Layers should
     * return the appropriate object if they desire to receive MouseEvents. The
     * easiest thing for a Layer to do in order to receive MouseEvents is to
     * implement the MapMouseListener interface and return itself. A code
     * snippet: <code><pre>
     * public MapMouseListener getMapMouseListener() {
     *     return this;
     * }
     * 
     * public String[] getMouseModeServiceList() {
     *     return new String[] { SelectMouseMode.modeID };
     * }
     * </pre></code>
     * 
     * @return null
     */
    public MapMouseListener getMapMouseListener() {
        return null;
    }

    /**
     * A GUI query method for other components to use to display whether gui
     * controls are available for this layer. If your layer provides gui
     * controls and the LayersPanel is being used in your application, you
     * should override this method in your layer to return true. This will allow
     * the other gui components to know that your layer has controls, while
     * still not actually building those controls until they are needed by the
     * user.
     * 
     * @return
     */
    public boolean hasGUI() {
        boolean hasGUI = false;
        try {
            Method guiMethod = getClass().getMethod("getGUI", (Class[]) null);
            hasGUI = (guiMethod.getDeclaringClass() != Layer.class);
        } catch (Exception e) {
            hasGUI = getGUI() != null;
        }

        return hasGUI;
    }

    /**
     * Gets the gui controls associated with the layer. This default
     * implementation returns null indicating that the layer has no gui
     * controls.
     * 
     * @return java.awt.Component or null
     */
    public Component getGUI() {
        return null;
    }

    // /////////////////////////////////////////////////
    // InfoDisplay Handling Setup and Firing

    /**
     * Adds a listener for <code>InfoDisplayEvent</code>s.
     * 
     * @param aInfoDisplayListener the listener to add
     */
    public synchronized void addInfoDisplayListener(
                                                    InfoDisplayListener aInfoDisplayListener) {
        if (IDListeners == null) {
            IDListeners = new ListenerSupport(this);
        }
        IDListeners.addListener(aInfoDisplayListener);
    }

    /**
     * Removes an InfoDisplayListener from this Layer.
     * 
     * @param aInfoDisplayListener the listener to remove
     */
    public synchronized void removeInfoDisplayListener(
                                                       InfoDisplayListener aInfoDisplayListener) {

        if (IDListeners != null) {
            IDListeners.removeListener(aInfoDisplayListener);
        }
    }

    /**
     * Sends a request to the InfoDisplayListener to show the information in the
     * InfoDisplay event on an single line display facility.
     * 
     * @param evt the InfoDisplay event carrying the string.
     */
    public void fireRequestInfoLine(InfoDisplayEvent evt) {
        if (IDListeners != null) {
            for (Iterator it = IDListeners.iterator(); it.hasNext();) {
                ((InfoDisplayListener) it.next()).requestInfoLine(evt);
            }
        } else if (Debug.debugging("layer")) {
            Debug.output(getName()
                    + "|Layer.fireRequestInfoLine(): no info request listener!");
        }
    }

    /**
     * Sends a request to the InfoDisplay listener to display the information on
     * an single line display facility. The InfoDisplayEvent is created inside
     * this function.
     * 
     * @param infoLine the string to put in the InfoDisplayEvent.
     */
    public void fireRequestInfoLine(String infoLine) {
        fireRequestInfoLine(new InfoDisplayEvent(this, infoLine));
    }

    /**
     * Sends a request to the InfoDisplay listener to display the information on
     * an single line display facility at preferred location. The
     * InfoDisplayEvent is created inside this function.
     * 
     * @param infoLine the string to put in the InfoDisplayEvent.
     * @param loc the index of a preferred location, starting at 0.
     */
    public void fireRequestInfoLine(String infoLine, int loc) {
        fireRequestInfoLine(new InfoDisplayEvent(this, infoLine, loc));
    }

    /**
     * Sends a request to the InfoDisplay listener to display the information in
     * the InfoDisplay event in a Browser.
     * 
     * @param evt the InfoDisplayEvent holding the contents to put in the
     *        Browser.
     */
    public void fireRequestBrowserContent(InfoDisplayEvent evt) {
        if (IDListeners != null) {
            for (Iterator it = IDListeners.iterator(); it.hasNext();) {
                ((InfoDisplayListener) it.next()).requestBrowserContent(evt);
            }
        } else if (Debug.debugging("layer")) {
            Debug.output(getName()
                    + "|Layer.fireRequestBrowserContent(): no info request listener!");
        }
    }

    /**
     * Sends a request to the InfoDisplayListener to display the information in
     * a Browser. The InfoDisplayEvent is created here holding the
     * browserContent
     * 
     * @param browserContent the contents to put in the Browser.
     */
    public void fireRequestBrowserContent(String browserContent) {
        fireRequestBrowserContent(new InfoDisplayEvent(this, browserContent));
    }

    /**
     * Sends a request to the InfoDisplayListener to display a URL given in the
     * InfoDisplay event in a Browser.
     * 
     * @param evt the InfoDisplayEvent holding the url location to give to the