droplistenersupport.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/tools/dnd/DropListenerSupport.java,v $
//$RCSfile: DropListenerSupport.java,v $
//$Revision: 1.1.1.1.2.2 $
//$Date: 2005/08/09 21:17:57 $
//$Author: dietrick $
//
//**********************************************************************

package com.bbn.openmap.tools.dnd;

import java.awt.event.*;
import java.beans.*;
import java.util.*;
import java.beans.beancontext.*;

import com.bbn.openmap.*;
import com.bbn.openmap.util.Debug;

/**
 * The DropListenerSupport manages the DefaultDnDCatchers that handle
 * Drag and Drop events on the map. There should only be one
 * DropListenerSupport within a MapHandler.
 * 
 * DropListenerSupport keeps a list of all DefaultDnDCatcher objects
 * from a MapHandler. It adds itself to the MapBean as MouseListener
 * and MouseMotionListener. On MousePressed, MouseDragged, and
 * MouseReleased events it loops through the DnDCatchers and invokes a
 * consume() method in each of them.
 * 
 * @see DefaultDnDCatcher
 */
public class DropListenerSupport implements PropertyChangeListener,
        java.io.Serializable, BeanContextChild, BeanContextMembershipListener,
        SoloMapComponent, MouseListener, MouseMotionListener {

    /**
     * Holds a list of DefaultDndCatchers
     */
    protected transient Vector dndCatchers = new Vector(2);

    /**
     * The MapBean.
     */
    protected transient MapBean map;

    /**
     * PropertyChangeSupport for handling listeners.
     */
    protected PropertyChangeSupport pcSupport = new PropertyChangeSupport(this);

    /**
     * BeanContextChildSupport object provides helper functions for
     * BeanContextChild interface.
     */
    protected BeanContextChildSupport beanContextChildSupport = new BeanContextChildSupport(this);

    /**
     * Construct a DropListenerSupport without an associated MapBean.
     * You will need to set the MapBean via <code>setMap()</code>.
     * 
     * @see #setMap
     */
    public DropListenerSupport() {
        this(null);
    }

    /**
     * Construct a DropListenerSupport with an associated MapBean.
     * 
     * @param map MapBean
     */
    public DropListenerSupport(MapBean map) {
        setMap(map);
    }

    public void addPropertyChangeListener(PropertyChangeListener listener) {
        pcSupport.addPropertyChangeListener(listener);
    }

    /** Method for BeanContextChild interface. */
    public void addPropertyChangeListener(String propertyName,
                                          PropertyChangeListener in_pcl) {
        pcSupport.addPropertyChangeListener(propertyName, in_pcl);
    }

    /** Method for BeanContextChild interface. */
    public void addVetoableChangeListener(String propertyName,
                                          VetoableChangeListener in_vcl) {
        beanContextChildSupport.addVetoableChangeListener(propertyName, in_vcl);
    }

    /**
     * BeanContextMembershipListener method. Called when new objects
     * are added to the parent BeanContext.
     * 
     * @param bcme event that contains an iterator that can be used to
     *        go through the new objects.
     */
    public void childrenAdded(BeanContextMembershipEvent bcme) {
        findAndInit(bcme.iterator());
    }

    /**
     * BeanContextMembershipListener method. Called when objects have
     * been removed from the parent BeanContext. The
     * DropListenerSupport looks for the MapBean it is managing
     * MouseEvents for, and any DefaultDndCatchers that may be
     * removed.
     * 
     * @param bcme event that contains an iterator that can be used to
     *        go through the removed objects.
     */
    public void childrenRemoved(BeanContextMembershipEvent bcme) {
        Iterator it = bcme.iterator();
        while (it.hasNext()) {
            findAndUndo(it.next());
        }
    }

    /**
     * Called when an object should be evaluated by the
     * DropListenerSupport to see if it is needed.
     */
    public void findAndInit(Object someObj) {
        if (someObj instanceof MapBean) {
            Debug.message("droplistenersupport",
                    "DropListenerSupport found a map.");
            setMap((MapBean) someObj);
        }

        if (someObj instanceof DefaultDnDCatcher) {
            getBeanContext().addBeanContextMembershipListener((DefaultDnDCatcher) someObj);
            Debug.message("DropListener",
                    "DropListener found a DefaultDnDCatcher.");
            dndCatchers.addElement(someObj);
        }
    }

    /**
     * Eventually gets called when the DropListenerSupport is added to
     * the BeanContext, and when other objects are added to the
     * BeanContext anytime after that. The DropListenerSupport looks
     * for a MapBean to manage MouseEvents for, and DefaultDndCatchers
     * to use to manage those events. If a MapBean is added to the
     * BeanContext while another already is in use, the second MapBean
     * will take the place of the first.
     * 
     * @param it iterator to use to go through the new objects in the
     *        BeanContext.
     */
    public void findAndInit(Iterator it) {
        while (it.hasNext()) {
            findAndInit(it.next());
        }
    }

    /**
     * Called by childrenRemoved.
     */
    public void findAndUndo(Object someObj) {
        if (someObj instanceof MapBean) {
            if (getMap() == (MapBean) someObj) {
                Debug.message("droplistenersupport",
                        "DropListenerSupport: removing the map.");
                setMap(null);
            }
        }
    }

    public void firePropertyChange(String property, Object oldObj, Object newObj) {

        pcSupport.firePropertyChange(property, oldObj, newObj);
    }

    /**
     * Report a vetoable property update to any registered listeners.
     * If anyone vetos the change, then fire a new event reverting
     * everyone to the old value and then rethrow the
     * PropertyVetoException.
     * <P>
     * 
     * No event is fired if old and new are equal and non-null.
     * <P>
     * 
     * @param name The programmatic name of the property that is about
     *        to change
     * 
     * @param oldValue The old value of the property
     * @param newValue - The new value of the property
     * 
     * @throws PropertyVetoException if the recipient wishes the
     *         property change to be rolled back.
     */
    public void fireVetoableChange(String name, Object oldValue, Object newValue)
            throws PropertyVetoException {
        beanContextChildSupport.fireVetoableChange(name, oldValue, newValue);
    }

    /** Method for BeanContextChild interface. */
    public BeanContext getBeanContext() {
        return beanContextChildSupport.getBeanContext();
    }

    /**
     * Get the associated MapBean.
     * 
     * @return MapBean
     */
    public MapBean getMap() {
        return map;
    }

    /**
     * Invoked when the mouse has been clicked on a component.
     */
    public void mouseClicked(java.awt.event.MouseEvent e) {}

    /**
     * Invoked when a mouse button is pressed on a component and then
     * dragged. Mouse drag events will continue to be delivered to the
     * component where the first originated until the mouse button is
     * released (regardless of whether the mouse position is within
     * the bounds of the component).
     */
    public void mouseDragged(java.awt.event.MouseEvent e) {
        for (int i = 0; i < dndCatchers.size(); i++) {
            if (((DefaultDnDCatcher) dndCatchers.get(i)).consume(e))
                break;
        }
    }

    /**
     * Invoked when the mouse enters a component.
     */
    public void mouseEntered(java.awt.event.MouseEvent e) {}

    /**
     * Invoked when the mouse exits a component.
     */
    public void mouseExited(java.awt.event.MouseEvent e) {}

    /**
     * Invoked when the mouse button has been moved on a component
     * (with no buttons no down).
     */
    public void mouseMoved(java.awt.event.MouseEvent e) {}

    /**
     * Invoked when a mouse button has been pressed on a component.
     */
    public void mousePressed(java.awt.event.MouseEvent e) {
        for (int i = 0; i < dndCatchers.size(); i++) {
            if (((DefaultDnDCatcher) dndCatchers.get(i)).consume(e))
                break;
        }
    }

    /**
     * Invoked when a mouse button has been released on a component.
     */
    public void mouseReleased(java.awt.event.MouseEvent e) {
        for (int i = 0; i < dndCatchers.size(); i++) {
            if (((DefaultDnDCatcher) dndCatchers.get(i)).consume(e))
                break;
        }
    }

    /**
     * PropertyChangeListenter Interface method.
     * 
     * @param evt PropertyChangeEvent
     */
    public void propertyChange(PropertyChangeEvent evt) {}

    public void removePropertyChangeListener(PropertyChangeListener listener) {
        pcSupport.removePropertyChangeListener(listener);
    }

    /** Method for BeanContextChild interface. */
    public void removePropertyChangeListener(String propertyName,
                                             PropertyChangeListener in_pcl) {
        pcSupport.removePropertyChangeListener(propertyName, in_pcl);
    }

    /** Method for BeanContextChild interface. */
    public void removeVetoableChangeListener(String propertyName,
                                             VetoableChangeListener in_vcl) {
        beanContextChildSupport.removeVetoableChangeListener(propertyName,
                in_vcl);
    }

    /** Method for BeanContextChild interface. */
    public void setBeanContext(BeanContext in_bc) throws PropertyVetoException {
        if (in_bc != null) {
            in_bc.addBeanContextMembershipListener(this);
            beanContextChildSupport.setBeanContext(in_bc);
            findAndInit(in_bc.iterator());
        }
    }

    /**
     * Set the associated MapBean.
     * 
     * @param mapbean MapBean
     */
    public void setMap(MapBean mapbean) {
        if (map != null) {
            map.removePropertyChangeListener(this);
            map.removeMouseListener(this);
            map.removeMouseMotionListener(this);
        }

        map = mapbean;
        if (map != null) {
            map.addPropertyChangeListener(this);
            map.addMouseListener(this);
            map.addMouseMotionListener(this);
        }
    }
}