/*
* Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved.
* 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. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle 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 Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.awt.dnd;
import java.awt.Component;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.awt.dnd.peer.DropTargetContextPeer;
import java.io.IOException;
import java.io.Serializable;
import java.util.Arrays;
import java.util.List;
/**
* A <code>DropTargetContext</code> is created
* whenever the logical cursor associated
* with a Drag and Drop operation coincides with the visible geometry of
* a <code>Component</code> associated with a <code>DropTarget</code>.
* The <code>DropTargetContext</code> provides
* the mechanism for a potential receiver
* of a drop operation to both provide the end user with the appropriate
* drag under feedback, but also to effect the subsequent data transfer
* if appropriate.
*
* @since 1.2
*/
public class DropTargetContext implements Serializable {
private static final long serialVersionUID = -634158968993743371L;
/**
* Construct a <code>DropTargetContext</code>
* given a specified <code>DropTarget</code>.
* <P>
* @param dt the DropTarget to associate with
*/
DropTargetContext(DropTarget dt) {
super();
dropTarget = dt;
}
/**
* This method returns the <code>DropTarget</code> associated with this
* <code>DropTargetContext</code>.
* <P>
* @return the <code>DropTarget</code> associated with this <code>DropTargetContext</code>
*/
public DropTarget getDropTarget() { return dropTarget; }
/**
* This method returns the <code>Component</code> associated with
* this <code>DropTargetContext</code>.
* <P>
* @return the Component associated with this Context
*/
public Component getComponent() { return dropTarget.getComponent(); }
/**
* Called when associated with the <code>DropTargetContextPeer</code>.
* <P>
* @param dtcp the <code>DropTargetContextPeer</code>
*/
public void addNotify(DropTargetContextPeer dtcp) {
dropTargetContextPeer = dtcp;
}
/**
* Called when disassociated with the <code>DropTargetContextPeer</code>.
*/
public void removeNotify() {
dropTargetContextPeer = null;
transferable = null;
}
/**
* This method sets the current actions acceptable to
* this <code>DropTarget</code>.
* <P>
* @param actions an <code>int</code> representing the supported action(s)
*/
protected void setTargetActions(int actions) {
DropTargetContextPeer peer = getDropTargetContextPeer();
if (peer != null) {
synchronized (peer) {
peer.setTargetActions(actions);
getDropTarget().doSetDefaultActions(actions);
}
} else {
getDropTarget().doSetDefaultActions(actions);
}
}
/**
* This method returns an <code>int</code> representing the
* current actions this <code>DropTarget</code> will accept.
* <P>
* @return the current actions acceptable to this <code>DropTarget</code>
*/
protected int getTargetActions() {
DropTargetContextPeer peer = getDropTargetContextPeer();
return ((peer != null)
? peer.getTargetActions()
: dropTarget.getDefaultActions()
);
}
/**
* This method signals that the drop is completed and
* if it was successful or not.
* <P>
* @param success true for success, false if not
* <P>
* @throws InvalidDnDOperationException if a drop is not outstanding/extant
*/
public void dropComplete(boolean success) throws InvalidDnDOperationException{
DropTargetContextPeer peer = getDropTargetContextPeer();
if (peer != null) {
peer.dropComplete(success);
}
}
/**
* accept the Drag.
* <P>
* @param dragOperation the supported action(s)
*/
protected void acceptDrag(int dragOperation) {
DropTargetContextPeer peer = getDropTargetContextPeer();
if (peer != null) {
peer.acceptDrag(dragOperation);
}
}
/**
* reject the Drag.
*/
protected void rejectDrag() {
DropTargetContextPeer peer = getDropTargetContextPeer();
if (peer != null) {
peer.rejectDrag();
}
}
/**
* called to signal that the drop is acceptable
* using the specified operation.
* must be called during DropTargetListener.drop method invocation.
* <P>
* @param dropOperation the supported action(s)
*/
protected void acceptDrop(int dropOperation) {
DropTargetContextPeer peer = getDropTargetContextPeer();
if (peer != null) {
peer.acceptDrop(dropOperation);
}
}
/**
* called to signal that the drop is unacceptable.
* must be called during DropTargetListener.drop method invocation.
*/
protected void rejectDrop() {
DropTargetContextPeer peer = getDropTargetContextPeer();
if (peer != null) {
peer.rejectDrop();
}
}
/**
* get the available DataFlavors of the
* <code>Transferable</code> operand of this operation.
* <P>
* @return a <code>DataFlavor[]</code> containing the
* supported <code>DataFlavor</code>s of the
* <code>Transferable</code> operand.
*/
protected DataFlavor[] getCurrentDataFlavors() {
DropTargetContextPeer peer = getDropTargetContextPeer();
return peer != null ? peer.getTransferDataFlavors() : new DataFlavor[0];
}
/**
* This method returns a the currently available DataFlavors
* of the <code>Transferable</code> operand
* as a <code>java.util.List</code>.
* <P>
* @return the currently available
* DataFlavors as a <code>java.util.List</code>
*/
protected List<DataFlavor> getCurrentDataFlavorsAsList() {
return Arrays.asList(getCurrentDataFlavors());
}
/**
* This method returns a <code>boolean</code>
* indicating if the given <code>DataFlavor</code> is
* supported by this <code>DropTargetContext</code>.
* <P>
* @param df the <code>DataFlavor</code>
* <P>
* @return if the <code>DataFlavor</code> specified is supported
*/
protected boolean isDataFlavorSupported(DataFlavor df) {
return getCurrentDataFlavorsAsList().contains(df);
}
/**
* get the Transferable (proxy) operand of this operation
* <P>
* @throws InvalidDnDOperationException if a drag is not outstanding/extant
* <P>
* @return the <code>Transferable</code>
*/
protected Transferable getTransferable() throws InvalidDnDOperationException {
DropTargetContextPeer peer = getDropTargetContextPeer();
if (peer == null) {
throw new InvalidDnDOperationException();
} else {
if (transferable == null) {
Transferable t = peer.getTransferable();
boolean isLocal = peer.isTransferableJVMLocal();
synchronized (this) {
if (transferable == null) {
transferable = createTransferableProxy(t, isLocal);
}
}
}
return transferable;
}
}
/**
* Get the <code>DropTargetContextPeer</code>
* <P>
* @return the platform peer
*/
DropTargetContextPeer getDropTargetContextPeer() {
return dropTargetContextPeer;
}
/**
* Creates a TransferableProxy to proxy for the specified
* Transferable.
*
* @param t the <tt>Transferable</tt> to be proxied
* @param local <tt>true</tt> if <tt>t</tt> represents
* the result of a local drag-n-drop operation.
* @return the new <tt>TransferableProxy</tt> instance.
*/
protected Transferable createTransferableProxy(Transferable t, boolean local) {
return new TransferableProxy(t, local);
}
/****************************************************************************/
/**
* <code>TransferableProxy</code> is a helper inner class that implements
* <code>Transferable</code> interface and serves as a proxy for another
* <code>Transferable</code> object which represents data transfer for
* a particular drag-n-drop operation.
* <p>
* The proxy forwards all requests to the encapsulated transferable
* and automatically performs additional conversion on the data
* returned by the encapsulated transferable in case of local transfer.
*/
protected class TransferableProxy implements Transferable {
/**
* Constructs a <code>TransferableProxy</code> given
* a specified <code>Transferable</code> object representing
* data transfer for a particular drag-n-drop operation and
* a <code>boolean</code> which indicates whether the
* drag-n-drop operation is local (within the same JVM).
* <p>
* @param t the <code>Transferable</code> object
* @param local <code>true</code>, if <code>t</code> represents
* the result of local drag-n-drop operation
*/
TransferableProxy(Transferable t, boolean local) {
proxy = new sun.awt.datatransfer.TransferableProxy(t, local);
transferable = t;
isLocal = local;
}
/**
* Returns an array of DataFlavor objects indicating the flavors
* the data can be provided in by the encapsulated transferable.
* <p>
* @return an array of data flavors in which the data can be
* provided by the encapsulated transferable
*/
public DataFlavor[] getTransferDataFlavors() {
return proxy.getTransferDataFlavors();
}
/**
* Returns whether or not the specified data flavor is supported by
* the encapsulated transferable.
* @param flavor the requested flavor for the data
* @return <code>true</code> if the data flavor is supported,
* <code>false</code> otherwise
*/
public boolean isDataFlavorSupported(DataFlavor flavor) {
return proxy.isDataFlavorSupported(flavor);
}
/**
* Returns an object which represents the data provided by
* the encapsulated transferable for the requested data flavor.
* <p>
* In case of local transfer a serialized copy of the object
* returned by the encapsulated transferable is provided when
* the data is requested in application/x-java-serialized-object
* data flavor.
*
* @param df the requested flavor for the data
* @throws IOException if the data is no longer available
* in the requested flavor.
* @throws UnsupportedFlavorException if the requested data flavor is
* not supported.
*/
public Object getTransferData(DataFlavor df)
throws UnsupportedFlavorException, IOException
{
return proxy.getTransferData(df);
}
/*
* fields
*/
// We don't need to worry about client code changing the values of
// these variables. Since TransferableProxy is a protected class, only
// subclasses of DropTargetContext can access it. And DropTargetContext
// cannot be subclassed by client code because it does not have a
// public constructor.
/**
* The encapsulated <code>Transferable</code> object.
*/
protected Transferable transferable;
/**
* A <code>boolean</code> indicating if the encapsulated
* <code>Transferable</code> object represents the result
* of local drag-n-drop operation (within the same JVM).
*/
protected boolean isLocal;
private sun.awt.datatransfer.TransferableProxy proxy;
}
/****************************************************************************/
/*
* fields
*/
/**
* The DropTarget associated with this DropTargetContext.
*
* @serial
*/
private DropTarget dropTarget;
private transient DropTargetContextPeer dropTargetContextPeer;
private transient Transferable transferable;
}