bufferedlayer.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/layer/BufferedLayer.java,v $
// $RCSfile: BufferedLayer.java,v $
// $Revision: 1.5.2.4 $
// $Date: 2005/08/09 19:21:28 $
// $Author: dietrick $
// 
// **********************************************************************

package com.bbn.openmap.layer;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Component;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Paint;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentEvent;
import java.awt.image.BufferedImage;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.beans.PropertyVetoException;
import java.beans.beancontext.BeanContext;
import java.util.Properties;
import java.util.Vector;

import javax.swing.BoxLayout;
import javax.swing.JCheckBox;
import javax.swing.JPanel;
import javax.swing.JTabbedPane;

import com.bbn.openmap.BufferedMapBean;
import com.bbn.openmap.Layer;
import com.bbn.openmap.LayerHandler;
import com.bbn.openmap.MapBean;
import com.bbn.openmap.omGraphics.OMColor;
import com.bbn.openmap.proj.Projection;
import com.bbn.openmap.util.Debug;
import com.bbn.openmap.util.PropUtils;

/**
 * A BufferedLayer is a layer that buffers a group of layers into an
 * image. When this layer repaints, the image gets rendered. This
 * layer can be used to group a set of layers into one, and was
 * designed with the idea that it is a background layer where a more
 * animated layer would be on top of it.
 * <P>
 * 
 * This layer contains a MapBean, and any layer that gets added to it
 * simply gets added to the MapBean. When a layer needs to redraw
 * itself, it can act normally, and the BufferedLayer will get updated
 * as needed. If the MapBean is a BufferedMapBean (which it is by
 * default), then the layers will get buffered into an image.
 * <P>
 * 
 * There are some special considerations to think about when using
 * this layer if the background is at all transparent. The image
 * buffer will need to be recreated at certain times in order to
 * prevent leftover images from the previous paintings. When the
 * background is set for the layer, the transparency is tested if the
 * background is a Color and the setHasTransparentBackground() method
 * is called accordingly. If a different Paint object is set in the
 * BufferedLayer, it's up to you to set this variable. This causes a
 * new image to be created every time a new projection is provided to
 * the layer. If the layers added to this BufferedLayer are active,
 * meaning that their content could change between projection changes,
 * you should set the hasActiveLayers flag to true. this causes a new
 * image buffer to be created every time a layer repaints itself.
 * Again, this is only important if the background color of the layer
 * is transparent.
 * <P>
 * 
 * The BufferedLayer can be configured in the openmap.properties file:
 * 
 * <pre>
 * 
 * 
 *  bufLayer.class=com.bbn.openmap.layer.BufferedLayer
 *  bufLayer.prettyName=My Layer Group
 *  bufLayer.layers=layer1 layer2 layer3
 *  bufLayer.visibleLayers=layer1 layer3
 *  bufLayer.hasActiveLayers=false
 * 
 *  
 * </pre>
 * 
 * layer1, layer2, etc should be defined as any other openmap layer.
 */
public class BufferedLayer extends Layer implements PropertyChangeListener {

    public final static String LayersProperty = "layers";
    public final static String VisibleLayersProperty = "visibleLayers";
    public final static String HasActiveLayersProperty = "hasActiveLayers";

    /**
     * Used to recreate the buffer on every repaint() call made by
     * every layer. Makes for a lot of image buffer creation. If the
     * layers may call repaint() and change what they present between
     * projection changes, then this needs to be set to true.
     * Otherwise, the old graphics will still be visible. This only
     * needs to be set if the background is at all transparent. If the
     * background of the internal MapBean is opaque, set this to
     * false, which is the default.
     */
    protected boolean hasActiveLayers = false;

    /**
     * Used to tell the BufferedLayer that the background is
     * transparent. Will cause a new image buffer to be created when
     * the projection changes, in order to cover up what was already
     * there. This is set to true but default, since the internal
     * MapBean color is set to OMColor.clear.
     */
    protected boolean hasTransparentBackground = true;

    /**
     * The MapBean used as the group organized. If this is a
     * BufferedMapBean, the layer will provide a buffered image.
     */
    MapBean mapBean;

    public BufferedLayer() {
        this.setLayout(new BorderLayout());

        // Adds the mapbean to the layer
        MapBean mb = new BLMapBean(this);

        // Add it the layer properly...
        setMapBean(mb);
    }

    public void setProperties(String prefix, Properties props) {
        super.setProperties(prefix, props);

        prefix = PropUtils.getScopedPropertyPrefix(prefix);

        hasActiveLayers = PropUtils.booleanFromProperties(props, prefix
                + HasActiveLayersProperty, hasActiveLayers);

        Vector layersValue = PropUtils.parseSpacedMarkers(props.getProperty(prefix
                + LayersProperty));
        Vector startuplayers = PropUtils.parseSpacedMarkers(props.getProperty(prefix
                + VisibleLayersProperty));

        Layer[] layers = LayerHandler.getLayers(layersValue,
                startuplayers,
                props);

        for (int i = 0; i < layers.length; i++) {
            mapBean.add(layers[i]);
        }
    }

    public Properties getProperties(Properties props) {
        props = super.getProperties(props);
        String prefix = PropUtils.getScopedPropertyPrefix(this);

        StringBuffer layersListProperty = new StringBuffer();
        StringBuffer startupLayersListProperty = new StringBuffer();

        Component[] comps = mapBean.getComponents();
        for (int i = 0; i < comps.length; i++) {
            // they have to be layers
            Layer layer = (Layer) comps[i];
            String lPrefix = layer.getPropertyPrefix();
            boolean unsetPrefix = false;
            if (lPrefix == null) {
                lPrefix = "layer" + i;
                // I think we need to do this, in order to get proper
                // scoping in the properties. We'll unset it later...
                layer.setPropertyPrefix(lPrefix);
                unsetPrefix = true;
            }
            layersListProperty.append(" " + lPrefix);

            if (layer.isVisible()) {
                startupLayersListProperty.append(" " + lPrefix);
            }

            Debug.output("BufferedLayer: getting properties for "
                    + layer.getName() + " "
                    + layer.getProperties(new Properties()));

            layer.getProperties(props);

            if (unsetPrefix) {
                layer.setPropertyPrefix(null);
            }
        }

        props.put(prefix + LayersProperty, layersListProperty.toString());
        props.put(prefix + VisibleLayersProperty,
                startupLayersListProperty.toString());
        props.put(prefix + HasActiveLayersProperty,
                new Boolean(hasActiveLayers).toString());

        return props;
    }

    /**
     * Not really implemented, because the mechanism for providing a
     * set of properties that let you add a variable number of new
     * objects as children to this one.
     */
    public Properties getPropertyInfo(Properties props) {
        props = super.getPropertyInfo(props);

        return props;
    }

    /**
     * If true, will cause a new image buffer to be recreated for
     * every layer.repaint() call. Should only be set to true if the
     * background is at all transparent, and if the layers could
     * change between projection changes.
     */
    public void setHasActiveLayers(boolean value) {
        hasActiveLayers = value;
    }

    public boolean getHasActiveLayers() {
        return hasActiveLayers;
    }

    /**
     * If true, will create a new image buffer when the projection
     * changes. Should be set to true if the background has any
     * transparency.
     */
    public void setHasTransparentBackground(boolean value) {
        hasTransparentBackground = value;
    }

    public boolean getHasTransparentBackground() {
        return hasTransparentBackground;
    }

    /**
     * Remove all layers from the group.
     */
    public void clearLayers() {
        Component[] layers = getLayers();
        if (layers != null && layers.length > 0) {
            for (int i = 0; i < layers.length; i++) {
                removeLayer((Layer) layers[i]);
            }
        }

        resetPalette();
    }

    /**
     * Method for BeanContextChild interface. Gets an iterator from
     * the BeanContext to call findAndInit() over. Sets BeanContext on
     * sub-layers.
     */
    public void setBeanContext(BeanContext in_bc) throws PropertyVetoException {
        super.setBeanContext(in_bc);

        Component[] layers = getLayers();
        if (layers != null && layers.length > 0) {
            for (int i = 0; i < layers.length; i++) {
                ((Layer) layers[i]).setBeanContext(in_bc);
            }
        }
    }

    /**
     * Add a layer to the group. Sets the BeanContext on the added
     * layer.
     */
    public void addLayer(Layer layer) {
        mapBean.add(layer);
        try {
            layer.setBeanContext(getBeanContext());
        } catch (PropertyVetoException nve) {
        }
        resetPalette();
    }

    /**
     * Remove the layer from group.
     */