informationdelegator.java

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

    /**
     * Display a html String in a window.
     */
    public void displayBrowserContent(String content) {
        MapHandler mh = (MapHandler) getBeanContext();
        Frame frame = null;
        if (mh != null) {
            frame = (Frame) mh.get(java.awt.Frame.class);
        }

        com.bbn.openmap.gui.MiniBrowser.display(frame, "text/html", content);
    }

    /**
     * Display a line of text in a info line.
     */
    public void displayInfoLine(String infoLine) {
        displayInfoLine(infoLine, MAP_OBJECT_INFO_LINE);
    }

    /**
     * Display a line of text in a designated info line.
     */
    public void displayInfoLine(String infoLine, int labelDesignator) {
        if (infoLineHolder != null) {
            setLabel((infoLine != null && infoLine.length() > 0) ? infoLine
                    : fudgeString, labelDesignator);
        }
    }

    /**
     * Display a message in a pop-up window.
     */
    public void displayMessage(String title, String message) {
        if (Environment.getBoolean(Environment.UseInternalFrames)) {
            JOptionPane.showInternalMessageDialog(Environment.getInternalFrameDesktop(),
                    message,
                    title,
                    JOptionPane.INFORMATION_MESSAGE);
        } else {
            JOptionPane.showMessageDialog(null,
                    message,
                    title,
                    JOptionPane.INFORMATION_MESSAGE);
        }
    }

    ///////////////////////////////////////////
    //  InfoDisplayListener interface

    /**
     * Handle layer requests to have a URL displayed in a Browser.
     * 
     * @param event InfoDisplayEvent
     */
    public void requestURL(InfoDisplayEvent event) {
        displayURL(event.getInformation());
    }

    /**
     * Handle layer requests to have a message displayed in a dialog
     * window.
     * 
     * @param event InfoDisplayEvent
     */
    public void requestMessage(InfoDisplayEvent event) {
        Layer l = event.getLayer();
        String layername = (l == null) ? null : l.getName();
        displayMessage("Message from " + layername + " layer:",
                event.getInformation());
    }

    /**
     * Handle layer requests to have an information line displayed in
     * an application status window.
     * 
     * @param event InfoDisplayEvent
     */
    public void requestInfoLine(InfoDisplayEvent event) {
        displayInfoLine(event.getInformation(), event.getPreferredLocation());
    }

    /**
     * Handle layer requests that plain text or html text be displayed
     * in a browser.
     * 
     * @param event InfoDisplayEvent
     */
    public void requestBrowserContent(InfoDisplayEvent event) {
        displayBrowserContent(event.getInformation());
    }

    /**
     * If a tooltip is required over a spot on the map then a
     * <code>MouseMapListener</code> should pass a MouseEvent to
     * this method. The Swing ToolTipManager is used to achieve this.
     * A call to this method should always be followed by a call to
     * <code>hideToolTip</code>
     * 
     * @param me A MouseEvent from a <code>MapMouseListener</code>
     *        which indicates where the tooltip is to appear (unused)
     * @param event an event containing the ToolTip to show
     * @deprecated use requestShowToolTip(InfoDisplayEvent) instead.
     */
    public void requestShowToolTip(MouseEvent me, InfoDisplayEvent event) {
        requestShowToolTip(event);
    }

    /**
     * If a tooltip is required over a spot on the map then a
     * <code>MouseMapListener</code> should pass a MouseEvent to
     * this method. The Swing ToolTipManager is used to achieve this.
     * A call to this method should always be followed by a call to
     * <code>hideToolTip</code>
     * 
     * @param event an event containing the ToolTip to show
     */
    public void requestShowToolTip(InfoDisplayEvent event) {
        //shows a tooltip over the map
        if (map != null) {
            if (ttmanager == null) {
                initToolTip();
            }
            map.setToolTipText(event.getInformation());
        }
    }

    /**
     * This method should follow a call to showToolTip in order to
     * indicate that the tooltip should no longer be displayed. This
     * method should always follow a call to <code>showToolTip</code?
     *
     * @param me A MouseEvent which passes from a MapMouseListener to
     * indicate that a tooltip should disappear 
     * @deprecated call requestHideToolTip() instead.
     */
    public void requestHideToolTip(MouseEvent me) {
        requestHideToolTip();
    }

    /**
     * This method should follow a call to showToolTip in order to
     * indicate that the tooltip should no longer be displayed. This
     * method should always follow a call to <code>showToolTip</code?
     */
    public void requestHideToolTip() {
        initToolTip();
    }

    /**
     * This method should be called to intialize the tooltip status so
     * that an old tooltip doesn't remain when a layer starts
     * listening to mouse events.
     */
    public void initToolTip() {
        if (ttmanager == null) {
            //make sure the MapBean is registered first
            ttmanager = ToolTipManager.sharedInstance();
            ttmanager.registerComponent(map);
            ttmanager.setEnabled(true);
            return;
        }

        // If it already exists, clear out the current tip
        if (map != null) {
            map.setToolTipText(null);
        }
    }

    /**
     * Change the cursor for the MapBean. If the MapBean hasn't been
     * set, then nothing will happen on the screen. If a null value is
     * passed in, the cursor is reset to the MouseMode value. If the
     * InformationDelegator is alowed to show the wait cursor, and the
     * layers are busy, the wait cursor will take precidence. The
     * requested cursor from a layer will be set if the layers finish.
     * 
     * @param cursor java.awt.Cursor to change the cursor to.
     */
    public void requestCursor(java.awt.Cursor cursor) {
        // This is interpreted as a release from a requester
        if (cursor == null) {
            // If we're not supposed to be showing the wait cursor...
            if (showWaitCursor && !waitingForLayers)
                resetCursor();
            // Set this to null, so that when we're done waiting for
            // the layers, we'll just reset.
            currentMapBeanCursor = null;
        } else if (this.map != null) {
            Cursor newCursor;
            // If we're supposed to be showing the watch, do it, but
            // save the request for when the layers are done.
            if (showWaitCursor && waitingForLayers) {
                newCursor = Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR);
                currentMapBeanCursor = cursor;
            } else
                newCursor = cursor;

            map.setCursor(newCursor);
        }
    }

    /**
     * Set the cursor to use when the waiting is done, if a layer
     * hasn't asked for one to be displayed. For the MouseMode
     * changes, this is automatically called.
     */
    public void setResetCursor(java.awt.Cursor cursor) {
        fallbackMapBeanCursor = cursor;
    }

    /**
     * Sets the cursor over the mapbean to the assigned default, or
     * whatever has been set by the MouseMode.
     */
    public void resetCursor() {
        if (this.map != null)
            map.setCursor(fallbackMapBeanCursor);
    }

    /**
     * If the value passed in is true, the cursor over the MapBean
     * will be the waiting cursor layers are off working. The status
     * lights will work, too, no matter what the value is. If false,
     * the cursor won't change if the layers are working.
     */
    public void setShowWaitCursor(boolean value) {
        showWaitCursor = value;
    }

    /**
     * Returns whether the wait cursor will be shown if the layers are
     * working.
     */
    public boolean isShowWaitCursor() {
        return showWaitCursor;
    }

    //////////// MapHandlerChild methods overridden from
    // OMComponentPanel

    /**
     * Called when an object has been added to the BeanContext. The
     * InformationDelegator will look for certain objects it needs.
     */
    public void findAndInit(Object someObj) {
        if (someObj instanceof MapBean) {
            setMap((MapBean) someObj);
        }
        if (someObj instanceof MouseDelegator) {
            MouseDelegator md = (MouseDelegator) someObj;
            md.addPropertyChangeListener(this);
        }

        statusBar.findAndInit(someObj);
    }

    /**
     * Called when an object is being removed from the BeanContext.
     * Will cause the object to be disconnected from the
     * InformationDelegator if it is being used.
     */
    public void findAndUndo(Object someObj) {
        if (someObj instanceof MapBean) {
            setMap(null);
        }
        if (someObj instanceof MouseDelegator) {
            MouseDelegator md = (MouseDelegator) someObj;
            md.removePropertyChangeListener(this);
        }

        statusBar.findAndUndo(someObj);
    }

    /////// PropertyConsumer methods overridden from OMComponentPanel

    public void setProperties(String prefix, Properties props) {
        setPropertyPrefix(prefix);
        prefix = PropUtils.getScopedPropertyPrefix(prefix);

        statusBar.setProperties(prefix, props);
        setShowLights(PropUtils.booleanFromProperties(props, prefix
                + ShowLightsProperty, showLights));
        setShowInfoLine(PropUtils.booleanFromProperties(props, prefix
                + ShowInfoLineProperty, showInfoLine));

        String pl = props.getProperty(prefix + PreferredLocationProperty);
        if (pl != null) {
            setPreferredLocation(pl);
        }
    }

    public Properties getProperties(Properties props) {
        if (props == null) {
            props = new Properties();
        }

        statusBar.getProperties(props);
        String prefix = PropUtils.getScopedPropertyPrefix(this);
        props.put(prefix + ShowLightsProperty,
                new Boolean(showLights).toString());
        props.put(prefix + ShowInfoLineProperty,
                new Boolean(showInfoLine).toString());
        props.put(prefix + PreferredLocationProperty, getPreferredLocation());
        return props;
    }

    public Properties getPropertyInfo(Properties props) {
        if (props == null) {
            props = new Properties();
        }

        statusBar.getPropertyInfo(props);
        props.put(ShowLightsProperty, "Show the layer status lights");
        props.put(ShowLightsProperty + ScopedEditorProperty,
                "com.bbn.openmap.util.propertyEditor.YesNoPropertyEditor");
        props.put(ShowInfoLineProperty,
                "Show the information line below the map");
        props.put(ShowInfoLineProperty + ScopedEditorProperty,
                "com.bbn.openmap.util.propertyEditor.YesNoPropertyEditor");
        props.put(PreferredLocationProperty,
                "The preferred BorderLayout direction to place this component.");

        return props;
    }

    /////// Setters and Getters

    public void setInfoLineHolder(JLabel ilh) {
        infoLineHolder = ilh;
    }

    public JLabel getInfoLineHolder() {
        return infoLineHolder;
    }

    public void setProgressBar(JProgressBar progressBar) {
        this.progressBar = progressBar;
    }

    public JProgressBar getProgressBar() {
        return progressBar;
    }

    public void setShowLights(boolean set) {
        showLights = set;
        statusBar.setVisible(set);
    }

    public boolean getShowLights() {
        return showLights;
    }

    public void setShowInfoLine(boolean set) {
        showInfoLine = set;
        infoLineHolder.setVisible(set);
        infoLineHolder2.setVisible(set);
    }

    public boolean getShowInfoLine() {
        return showInfoLine;
    }

    public void setLightTriggers(boolean set) {
        statusBar.setLightTriggers(set);
    }

    public boolean getLightTriggers() {
        return statusBar.getLightTriggers();
    }

    public void setFloatable(boolean value) {}

    /**
     * BorderLayout.SOUTH by default for this class.
     */
    protected String preferredLocation = java.awt.BorderLayout.SOUTH;

    /**
     * MapPanelChild method.
     */
    public void setPreferredLocation(String value) {
        preferredLocation = value;
    }

    /**
     * MapPanelChild method.
     */
    public String getPreferredLocation() {
        return preferredLocation;
    }
}