droptarget.java

JAVA基本类源代码,大家可以学习学习!

     * Gets the <code>FlavorMap</code>
     * associated with this <code>DropTarget</code>.
     * If no <code>FlavorMap</code> has been set for this
     * <code>DropTarget</code>, it is associated with the default
     * <code>FlavorMap</code>.
     * <P>
     * @return the FlavorMap for this DropTarget
     */

    public FlavorMap getFlavorMap() { return flavorMap; }

    /**
     * Sets the <code>FlavorMap</code> associated
     * with this <code>DropTarget</code>.
     * <P>
     * @param fm the new <code>FlavorMap</code>, or null to 
     * associate the default FlavorMap with this DropTarget.
     */

    public void setFlavorMap(FlavorMap fm) {
        flavorMap = fm == null ? SystemFlavorMap.getDefaultFlavorMap() : fm;
    }

    /**
     * Notify the DropTarget that it has been associated with a Component
     *
     **********************************************************************
     * This method is usually called from java.awt.Component.addNotify() of
     * the Component associated with this DropTarget to notify the DropTarget
     * that a ComponentPeer has been associated with that Component.
     *
     * Calling this method, other than to notify this DropTarget of the
     * association of the ComponentPeer with the Component may result in
     * a malfunction of the DnD system.
     **********************************************************************
     * <P>
     * @param peer The Peer of the Component we are associated with!
     *
     */

    public void addNotify(ComponentPeer peer) {
	if (peer == componentPeer) return;

	componentPeer = peer;

        for (Component c = component; 
             c != null && peer instanceof LightweightPeer; c = c.getParent()) {
            peer = c.getPeer();
        }

        if (peer instanceof DropTargetPeer) {
            nativePeer = peer;
            ((DropTargetPeer)peer).addDropTarget(this);
        } else {
            nativePeer = null;
        }
    }

    /**
     * Notify the DropTarget that it has been disassociated from a Component
     *
     **********************************************************************
     * This method is usually called from java.awt.Component.removeNotify() of
     * the Component associated with this DropTarget to notify the DropTarget
     * that a ComponentPeer has been disassociated with that Component.
     *
     * Calling this method, other than to notify this DropTarget of the
     * disassociation of the ComponentPeer from the Component may result in
     * a malfunction of the DnD system.
     **********************************************************************
     * <P>
     * @param peer The Peer of the Component we are being disassociated from!
     */

    public void removeNotify(ComponentPeer peer) {
	if (nativePeer != null)
	    ((DropTargetPeer)nativePeer).removeDropTarget(this);

	componentPeer = nativePeer = null;
    }

    /**
     * Gets the <code>DropTargetContext</code> associated 
     * with this <code>DropTarget</code>.
     * <P>
     * @return the <code>DropTargetContext</code> associated with this <code>DropTarget</code>.
     */

    public DropTargetContext getDropTargetContext() {
	return dropTargetContext;
    }

    /**
     * Creates the DropTargetContext associated with this DropTarget.
     * Subclasses may override this method to instantiate their own
     * DropTargetContext subclass.
     *
     * This call is typically *only* called by the platform's
     * DropTargetContextPeer as a drag operation encounters this
     * DropTarget. Accessing the Context while no Drag is current
     * has undefined results.
     */

    protected DropTargetContext createDropTargetContext() {
	return new DropTargetContext(this);
    }

    /**
     * Serializes this <code>DropTarget</code>. Performs default serialization,
     * and then writes out this object's <code>DropTargetListener</code> if and
     * only if it can be serialized. If not, <code>null</code> is written
     * instead.
     *
     * @serialData The default serializable fields, in alphabetical order,
     *             followed by either a <code>DropTargetListener</code>
     *             instance, or <code>null</code>.
     * @since 1.4
     */
    private void writeObject(ObjectOutputStream s) throws IOException {
        s.defaultWriteObject();

        s.writeObject(SerializationTester.test(dtListener)
                      ? dtListener : null);
    }

    /**
     * Deserializes this <code>DropTarget</code>. This method first performs
     * default deserialization for all non-<code>transient</code> fields. An
     * attempt is then made to deserialize this object's
     * <code>DropTargetListener</code> as well. This is first attempted by
     * deserializing the field <code>dtListener</code>, because, in releases
     * prior to 1.4, a non-<code>transient</code> field of this name stored the
     * <code>DropTargetListener</code>. If this fails, the next object in the
     * stream is used instead.
     *
     * @since 1.4
     */
    private void readObject(ObjectInputStream s)
        throws ClassNotFoundException, IOException
    {
        ObjectInputStream.GetField f = s.readFields();

        try {
            dropTargetContext =
                (DropTargetContext)f.get("dropTargetContext", null);
        } catch (IllegalArgumentException e) {
            // Pre-1.4 support. 'dropTargetContext' was previoulsy transient
        }
        if (dropTargetContext == null) {
            dropTargetContext = createDropTargetContext();
        }

        component = (Component)f.get("component", null);
        actions = f.get("actions", DnDConstants.ACTION_COPY_OR_MOVE);
        active = f.get("active", true);

        // Pre-1.4 support. 'dtListener' was previously non-transient
        try {
            dtListener = (DropTargetListener)f.get("dtListener", null);
        } catch (IllegalArgumentException e) {
            // 1.4-compatible byte stream. 'dtListener' was written explicitly
            dtListener = (DropTargetListener)s.readObject();
        }
    }

    /*********************************************************************/

    /**
     * this protected nested class implements autoscrolling
     */

    protected static class DropTargetAutoScroller implements ActionListener {

	/**
         * construct a DropTargetAutoScroller
         * <P>
         * @param c the <code>Component</code>
         * @param p the <code>Point</code>
	 */

	protected DropTargetAutoScroller(Component c, Point p) {
	    super();

	    component  = c;
	    autoScroll = (Autoscroll)component;

	    Toolkit t  = Toolkit.getDefaultToolkit();

	    Integer    initial  = new Integer(100);
	    Integer    interval = new Integer(100);

	    try {
		initial = (Integer)t.getDesktopProperty("DnD.Autoscroll.initialDelay");
	    } catch (Exception e) {
		// ignore
	    }

	    try {
	        interval = (Integer)t.getDesktopProperty("DnD.Autoscroll.interval");
	    } catch (Exception e) {
		// ignore
	    }

	    timer  = new Timer(interval.intValue(), this);

	    timer.setCoalesce(true);
	    timer.setInitialDelay(initial.intValue());

	    locn = p;
	    prev = p;

	    try {
		hysteresis = ((Integer)t.getDesktopProperty("DnD.Autoscroll.cursorHysteresis")).intValue();
	    } catch (Exception e) {
		// ignore
	    }

	    timer.start();
	}

	/**
	 * update the geometry of the autoscroll region
	 */

	private void updateRegion() {
	   Insets    i    = autoScroll.getAutoscrollInsets();
	   Dimension size = component.getSize();

	   if (size.width != outer.width || size.height != outer.height)
		outer.reshape(0, 0, size.width, size.height);

	   if (inner.x != i.left || inner.y != i.top)
		inner.setLocation(i.left, i.top);
		
	   int newWidth  = size.width -  (i.left + i.right);
	   int newHeight = size.height - (i.top  + i.bottom);

	   if (newWidth != inner.width || newHeight != inner.height)
		inner.setSize(newWidth, newHeight);
	
	}

	/**
	 * cause autoscroll to occur
         * <P>
         * @param newLocn the <code>Point</code>
	 */

	protected synchronized void updateLocation(Point newLocn) {
	    prev = locn;
	    locn = newLocn;

	    if (Math.abs(locn.x - prev.x) > hysteresis ||
	   	Math.abs(locn.y - prev.y) > hysteresis) {
		if (timer.isRunning()) timer.stop();
	    } else {
		if (!timer.isRunning()) timer.start();
	    }
	}

	/**
	 * cause autoscrolling to stop
	 */

	protected void stop() { timer.stop(); }

	/**
	 * cause autoscroll to occur
         * <P>
         * @param e the <code>ActionEvent</code>
	 */

	public synchronized void actionPerformed(ActionEvent e) {
	    updateRegion();

	    if (outer.contains(locn) && !inner.contains(locn))
	        autoScroll.autoscroll(locn);
	}

	/*
	 * fields
	 */

	private Component  component;
	private Autoscroll autoScroll;

	private Timer      timer;

	private Point	   locn;
	private Point	   prev;

	private Rectangle  outer = new Rectangle();
	private Rectangle  inner = new Rectangle();

	private int	   hysteresis = 10;
    }

    /*********************************************************************/

    /**
     * create an embedded autoscroller
     * <P>
     * @param c the <code>Component</code>
     * @param p the <code>Point</code>
     */

    protected DropTargetAutoScroller createDropTargetAutoScroller(Component c, Point p) {
	return new DropTargetAutoScroller(c, p);
    }

    /**
     * initialize autoscrolling
     * <P>
     * @param p the <code>Point</code>
     */

    protected void initializeAutoscrolling(Point p) {
	if (component == null || !(component instanceof Autoscroll)) return;

	autoScroller = createDropTargetAutoScroller(component, p);
    }

    /**
     * update autoscrolling with current cursor locn
     * <P>
     * @param dragCursorLocn the <code>Point</code>
     */

    protected void updateAutoscroll(Point dragCursorLocn) {
	if (autoScroller != null) autoScroller.updateLocation(dragCursorLocn);
    }

    /**
     * clear autoscrolling
     */

    protected void clearAutoscroll() {
	if (autoScroller != null) {
	    autoScroller.stop();
	    autoScroller = null;
	}
    }

    /**
     * The DropTargetContext associated with this DropTarget.
     *
     * @serial
     */
    private DropTargetContext dropTargetContext = createDropTargetContext();

    /**
     * The Component associated with this DropTarget.
     *
     * @serial
     */
    private Component component;
 
    /*
     * That Component's  Peer
     */
    private transient ComponentPeer componentPeer;

    /*
     * That Component's "native" Peer
     */
    private transient ComponentPeer nativePeer;
 

    /**
     * Default permissible actions supported by this DropTarget.
     * 
     * @see #setDefaultActions
     * @see #getDefaultActions
     * @serial
     */
    int	    actions = DnDConstants.ACTION_COPY_OR_MOVE;

    /**
     * <code>true</code> if the DropTarget is accepting Drag & Drop operations.
     *
     * @serial
     */
    boolean active = true;

    /*
     * the auto scrolling object
     */

    private transient DropTargetAutoScroller autoScroller;

    /*
     * The delegate
     */

    private transient DropTargetListener dtListener;

    /*
     * The FlavorMap
     */

    private transient FlavorMap flavorMap = SystemFlavorMap.getDefaultFlavorMap();
}