/*

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun in the LICENSE file that accompanied this code.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

package java.awt.dnd;

import java.util.TooManyListenersException;

import java.io.IOException;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

import java.awt.Component;

import java.awt.Dimension;

import java.awt.GraphicsEnvironment;

import java.awt.HeadlessException;

import java.awt.Insets;

import java.awt.Point;

import java.awt.Rectangle;

import java.awt.Toolkit;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.datatransfer.FlavorMap;

import java.awt.datatransfer.SystemFlavorMap;

import javax.swing.Timer;

import java.awt.peer.ComponentPeer;

import java.awt.peer.LightweightPeer;

import java.awt.dnd.peer.DropTargetPeer;

/**

 * The <code>DropTarget</code> is associated

 * with a <code>Component</code> when that <code>Component</code>

 * wishes

 * to accept drops during Drag and Drop operations.

 * <P>

 *  Each

 * <code>DropTarget</code> is associated with a <code>FlavorMap</code>.

 * The default <code>FlavorMap</code> hereafter designates the

 * <code>FlavorMap</code> returned by <code>SystemFlavorMap.getDefaultFlavorMap()</code>.

 *

 * @since 1.2

 */

public class DropTarget implements DropTargetListener, Serializable {

    private static final long serialVersionUID = -6283860791671019047L;

    /**

     * Creates a new DropTarget given the <code>Component</code>

     * to associate itself with, an <code>int</code> representing

     * the default acceptable action(s) to

     * support, a <code>DropTargetListener</code>

     * to handle event processing, a <code>boolean</code> indicating

     * if the <code>DropTarget</code> is currently accepting drops, and

     * a <code>FlavorMap</code> to use (or null for the default <CODE>FlavorMap</CODE>).

     * <P>

     * The Component will receive drops only if it is enabled.

     * @param c         The <code>Component</code> with which this <code>DropTarget</code> is associated

     * @param ops       The default acceptable actions for this <code>DropTarget</code>

     * @param dtl       The <code>DropTargetListener</code> for this <code>DropTarget</code>

     * @param act       Is the <code>DropTarget</code> accepting drops.

     * @param fm        The <code>FlavorMap</code> to use, or null for the default <CODE>FlavorMap</CODE>

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     *            returns true

     * @see java.awt.GraphicsEnvironment#isHeadless

     */

    public DropTarget(Component c, int ops, DropTargetListener dtl,

                      boolean act, FlavorMap fm)

        throws HeadlessException

    {

        if (GraphicsEnvironment.isHeadless()) {

            throw new HeadlessException();

        }

        component = c;

        setDefaultActions(ops);

        if (dtl != null) try {

            addDropTargetListener(dtl);

        } catch (TooManyListenersException tmle) {

            // do nothing!

        }

        if (c != null) {

            c.setDropTarget(this);

            setActive(act);

        }

    }

    /**

     * Creates a <code>DropTarget</code> given the <code>Component</code>

     * to associate itself with, an <code>int</code> representing

     * the default acceptable action(s)

     * to support, a <code>DropTargetListener</code>

     * to handle event processing, and a <code>boolean</code> indicating

     * if the <code>DropTarget</code> is currently accepting drops.

     * <P>

     * The Component will receive drops only if it is enabled.

     * @param c         The <code>Component</code> with which this <code>DropTarget</code> is associated

     * @param ops       The default acceptable actions for this <code>DropTarget</code>

     * @param dtl       The <code>DropTargetListener</code> for this <code>DropTarget</code>

     * @param act       Is the <code>DropTarget</code> accepting drops.

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     *            returns true

     * @see java.awt.GraphicsEnvironment#isHeadless

     */

    public DropTarget(Component c, int ops, DropTargetListener dtl,

                      boolean act)

        throws HeadlessException

    {

        this(c, ops, dtl, act, null);

    }

    /**

     * Creates a <code>DropTarget</code>.

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     *            returns true

     * @see java.awt.GraphicsEnvironment#isHeadless

     */

    public DropTarget() throws HeadlessException {

        this(null, DnDConstants.ACTION_COPY_OR_MOVE, null, true, null);

    }

    /**

     * Creates a <code>DropTarget</code> given the <code>Component</code>

     * to associate itself with, and the <code>DropTargetListener</code>

     * to handle event processing.

     * <P>

     * The Component will receive drops only if it is enabled.

     * @param c         The <code>Component</code> with which this <code>DropTarget</code> is associated

     * @param dtl       The <code>DropTargetListener</code> for this <code>DropTarget</code>

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     *            returns true

     * @see java.awt.GraphicsEnvironment#isHeadless

     */

    public DropTarget(Component c, DropTargetListener dtl)

        throws HeadlessException

    {

        this(c, DnDConstants.ACTION_COPY_OR_MOVE, dtl, true, null);

    }

    /**

     * Creates a <code>DropTarget</code> given the <code>Component</code>

     * to associate itself with, an <code>int</code> representing

     * the default acceptable action(s) to support, and a

     * <code>DropTargetListener</code> to handle event processing.

     * <P>

     * The Component will receive drops only if it is enabled.

     * @param c         The <code>Component</code> with which this <code>DropTarget</code> is associated

     * @param ops       The default acceptable actions for this <code>DropTarget</code>

     * @param dtl       The <code>DropTargetListener</code> for this <code>DropTarget</code>

     * @exception HeadlessException if GraphicsEnvironment.isHeadless()

     *            returns true

     * @see java.awt.GraphicsEnvironment#isHeadless

     */

    public DropTarget(Component c, int ops, DropTargetListener dtl)

        throws HeadlessException

    {

        this(c, ops, dtl, true);

    }

    /**

     * Note: this interface is required to permit the safe association

     * of a DropTarget with a Component in one of two ways, either:

     * <code> component.setDropTarget(droptarget); </code>

     * or <code> droptarget.setComponent(component); </code>

     * <P>

     * The Component will receive drops only if it is enabled.

     * @param c The new <code>Component</code> this <code>DropTarget</code>

     * is to be associated with.<P>

     */

    public synchronized void setComponent(Component c) {

        if (component == c || component != null && component.equals(c))

            return;

        Component     old;

        ComponentPeer oldPeer = null;

        if ((old = component) != null) {

            clearAutoscroll();

            component = null;

            if (componentPeer != null) {

                oldPeer = componentPeer;

                removeNotify(componentPeer);

            }

            old.setDropTarget(null);

        }

        if ((component = c) != null) try {

            c.setDropTarget(this);

        } catch (Exception e) { // undo the change

            if (old != null) {

                old.setDropTarget(this);

                addNotify(oldPeer);

            }

        }

    }

    /**

     * Gets the <code>Component</code> associated

     * with this <code>DropTarget</code>.

     * <P>

     * @return the current <code>Component</code>

     */

    public synchronized Component getComponent() {

        return component;

    }

    /**

     * Sets the default acceptable actions for this <code>DropTarget</code>

     * <P>

     * @param ops the default actions

     * <P>

     * @see java.awt.dnd.DnDConstants

     */

    public void setDefaultActions(int ops) {

        getDropTargetContext().setTargetActions(ops & (DnDConstants.ACTION_COPY_OR_MOVE | DnDConstants.ACTION_REFERENCE));

    }

    /*

     * Called by DropTargetContext.setTargetActions()

     * with appropriate synchronization.

     */

    void doSetDefaultActions(int ops) {

        actions = ops;

    }

    /**

     * Gets an <code>int</code> representing the

     * current action(s) supported by this <code>DropTarget</code>.

     * <P>

     * @return the current default actions

     */

    public int getDefaultActions() {

        return actions;

    }

    /**

     * Sets the DropTarget active if <code>true</code>,

     * inactive if <code>false</code>.

     * <P>

     * @param isActive sets the <code>DropTarget</code> (in)active.

     */

    public synchronized void setActive(boolean isActive) {

        if (isActive != active) {

            active = isActive;

        }

        if (!active) clearAutoscroll();

    }

    /**

     * Reports whether or not

     * this <code>DropTarget</code>

     * is currently active (ready to accept drops).

     * <P>

     * @return <CODE>true</CODE> if active, <CODE>false</CODE> if not

     */

    public boolean isActive() {

        return active;

    }

    /**

     * Adds a new <code>DropTargetListener</code> (UNICAST SOURCE).

     * <P>

     * @param dtl The new <code>DropTargetListener</code>

     * <P>

     * @throws <code>TooManyListenersException</code> if a

     * <code>DropTargetListener</code> is already added to this

     * <code>DropTarget</code>.

     */

    public synchronized void addDropTargetListener(DropTargetListener dtl) throws TooManyListenersException {

        if (dtl == null) return;

        if (equals(dtl)) throw new IllegalArgumentException("DropTarget may not be its own Listener");

        if (dtListener == null)

            dtListener = dtl;

        else

            throw new TooManyListenersException();

    }

    /**

     * Removes the current <code>DropTargetListener</code> (UNICAST SOURCE).

     * <P>

     * @param dtl the DropTargetListener to deregister.

     */

    public synchronized void removeDropTargetListener(DropTargetListener dtl) {

        if (dtl != null && dtListener != null) {

            if(dtListener.equals(dtl))

                dtListener = null;

            else

                throw new IllegalArgumentException("listener mismatch");

        }

    }

    /**

     * Calls <code>dragEnter</code> on the registered

     * <code>DropTargetListener</code> and passes it

     * the specified <code>DropTargetDragEvent</code>.

     * Has no effect if this <code>DropTarget</code>

     * is not active.

     *

     * @param dtde the <code>DropTargetDragEvent</code>

     *

     * @throws NullPointerException if this <code>DropTarget</code>

     *         is active and <code>dtde</code> is <code>null</code>

     *

     * @see #isActive

     */

    public synchronized void dragEnter(DropTargetDragEvent dtde) {

        if (!active) return;

        if (dtListener != null) {

            dtListener.dragEnter(dtde);

        } else

            dtde.getDropTargetContext().setTargetActions(DnDConstants.ACTION_NONE);

        initializeAutoscrolling(dtde.getLocation());

    }

    /**

     * Calls <code>dragOver</code> on the registered

     * <code>DropTargetListener</code> and passes it

     * the specified <code>DropTargetDragEvent</code>.

     * Has no effect if this <code>DropTarget</code>

     * is not active.

     *

     * @param dtde the <code>DropTargetDragEvent</code>

     *

     * @throws NullPointerException if this <code>DropTarget</code>

     *         is active and <code>dtde</code> is <code>null</code>

     *

     * @see #isActive

     */

    public synchronized void dragOver(DropTargetDragEvent dtde) {

        if (!active) return;

        if (dtListener != null && active) dtListener.dragOver(dtde);

        updateAutoscroll(dtde.getLocation());

    }

    /**

     * Calls <code>dropActionChanged</code> on the registered

     * <code>DropTargetListener</code> and passes it

     * the specified <code>DropTargetDragEvent</code>.

     * Has no effect if this <code>DropTarget</code>

     * is not active.

     *

     * @param dtde the <code>DropTargetDragEvent</code>

     *

     * @throws NullPointerException if this <code>DropTarget</code>

     *         is active and <code>dtde</code> is <code>null</code>

     *

     * @see #isActive

     */

    public synchronized void dropActionChanged(DropTargetDragEvent dtde) {

        if (!active) return;

        if (dtListener != null) dtListener.dropActionChanged(dtde);

        updateAutoscroll(dtde.getLocation());

    }

    /**

     * Calls <code>dragExit</code> on the registered

     * <code>DropTargetListener</code> and passes it

     * the specified <code>DropTargetEvent</code>.

     * Has no effect if this <code>DropTarget</code>

     * is not active.

     * <p>

     * This method itself does not throw any exception

     * for null parameter but for exceptions thrown by

     * the respective method of the listener.

     *

     * @param dte the <code>DropTargetEvent</code>

     *

     * @see #isActive

     */

    public synchronized void dragExit(DropTargetEvent dte) {

        if (!active) return;

        if (dtListener != null && active) dtListener.dragExit(dte);

        clearAutoscroll();

    }

    /**

     * Calls <code>drop</code> on the registered

     * <code>DropTargetListener</code> and passes it

     * the specified <code>DropTargetDropEvent</code>

     * if this <code>DropTarget</code> is active.

     *

     * @param dtde the <code>DropTargetDropEvent</code>

     *

     * @throws NullPointerException if <code>dtde</code> is null

     *         and at least one of the following is true: this

     *         <code>DropTarget</code> is not active, or there is

     *         no a <code>DropTargetListener</code> registered.

     *

     * @see #isActive

     */

    public synchronized void drop(DropTargetDropEvent dtde) {

        clearAutoscroll();

        if (dtListener != null && active)

            dtListener.drop(dtde);

        else { // we should'nt get here ...

            dtde.rejectDrop();

        }

    }

    /**

     * 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!