/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*
*/
package javax.swing;
import java.awt.*;
import java.awt.event.*;
import java.awt.datatransfer.*;
import java.awt.dnd.*;
import java.beans.*;
import java.lang.reflect.*;
import java.io.*;
import java.util.
TooManyListenersException;
import javax.swing.plaf.
UIResource;
import javax.swing.event.*;
import javax.swing.text.
JTextComponent;
import sun.reflect.misc.
MethodUtil;
import sun.swing.
SwingUtilities2;
import sun.awt.
AppContext;
import sun.swing.*;
import sun.awt.
SunToolkit;
import java.security.
AccessController;
import java.security.
PrivilegedAction;
import java.security.
AccessControlContext;
import java.security.
ProtectionDomain;
import sun.misc.
SharedSecrets;
import sun.misc.
JavaSecurityAccess;
import sun.awt.
AWTAccessor;
/**
* This class is used to handle the transfer of a <code>Transferable</code>
* to and from Swing components. The <code>Transferable</code> is used to
* represent data that is exchanged via a cut, copy, or paste
* to/from a clipboard. It is also used in drag-and-drop operations
* to represent a drag from a component, and a drop to a component.
* Swing provides functionality that automatically supports cut, copy,
* and paste keyboard bindings that use the functionality provided by
* an implementation of this class. Swing also provides functionality
* that automatically supports drag and drop that uses the functionality
* provided by an implementation of this class. The Swing developer can
* concentrate on specifying the semantics of a transfer primarily by setting
* the <code>transferHandler</code> property on a Swing component.
* <p>
* This class is implemented to provide a default behavior of transferring
* a component property simply by specifying the name of the property in
* the constructor. For example, to transfer the foreground color from
* one component to another either via the clipboard or a drag and drop operation
* a <code>TransferHandler</code> can be constructed with the string "foreground". The
* built in support will use the color returned by <code>getForeground</code> as the source
* of the transfer, and <code>setForeground</code> for the target of a transfer.
* <p>
* Please see
* <a href="https://docs.oracle.com/javase/tutorial/uiswing/dnd/index.html">
* How to Use Drag and Drop and Data Transfer</a>,
* a section in <em>The Java Tutorial</em>, for more information.
*
*
* @author Timothy Prinzing
* @author Shannon Hickey
* @since 1.4
*/
@
SuppressWarnings("serial")
public class
TransferHandler implements
Serializable {
/**
* An <code>int</code> representing no transfer action.
*/
public static final int
NONE =
DnDConstants.
ACTION_NONE;
/**
* An <code>int</code> representing a "copy" transfer action.
* This value is used when data is copied to a clipboard
* or copied elsewhere in a drag and drop operation.
*/
public static final int
COPY =
DnDConstants.
ACTION_COPY;
/**
* An <code>int</code> representing a "move" transfer action.
* This value is used when data is moved to a clipboard (i.e. a cut)
* or moved elsewhere in a drag and drop operation.
*/
public static final int
MOVE =
DnDConstants.
ACTION_MOVE;
/**
* An <code>int</code> representing a source action capability of either
* "copy" or "move".
*/
public static final int
COPY_OR_MOVE =
DnDConstants.
ACTION_COPY_OR_MOVE;
/**
* An <code>int</code> representing a "link" transfer action.
* This value is used to specify that data should be linked in a drag
* and drop operation.
*
* @see java.awt.dnd.DnDConstants#ACTION_LINK
* @since 1.6
*/
public static final int
LINK =
DnDConstants.
ACTION_LINK;
/**
* An interface to tag things with a {@code getTransferHandler} method.
*/
interface
HasGetTransferHandler {
/** Returns the {@code TransferHandler}.
*
* @return The {@code TransferHandler} or {@code null}
*/
public
TransferHandler getTransferHandler();
}
/**
* Represents a location where dropped data should be inserted.
* This is a base class that only encapsulates a point.
* Components supporting drop may provide subclasses of this
* containing more information.
* <p>
* Developers typically shouldn't create instances of, or extend, this
* class. Instead, these are something provided by the DnD
* implementation by <code>TransferSupport</code> instances and by
* components with a <code>getDropLocation()</code> method.
*
* @see javax.swing.TransferHandler.TransferSupport#getDropLocation
* @since 1.6
*/
public static class
DropLocation {
private final
Point dropPoint;
/**
* Constructs a drop location for the given point.
*
* @param dropPoint the drop point, representing the mouse's
* current location within the component.
* @throws IllegalArgumentException if the point
* is <code>null</code>
*/
protected
DropLocation(
Point dropPoint) {
if (
dropPoint == null) {
throw new
IllegalArgumentException("Point cannot be null");
}
this.
dropPoint = new
Point(
dropPoint);
}
/**
* Returns the drop point, representing the mouse's
* current location within the component.
*
* @return the drop point.
*/
public final
Point getDropPoint() {
return new
Point(
dropPoint);
}
/**
* Returns a string representation of this drop location.
* This method is intended to be used for debugging purposes,
* and the content and format of the returned string may vary
* between implementations.
*
* @return a string representation of this drop location
*/
public
String toString() {
return
getClass().
getName() + "[dropPoint=" +
dropPoint + "]";
}
};
/**
* This class encapsulates all relevant details of a clipboard
* or drag and drop transfer, and also allows for customizing
* aspects of the drag and drop experience.
* <p>
* The main purpose of this class is to provide the information
* needed by a developer to determine the suitability of a
* transfer or to import the data contained within. But it also
* doubles as a controller for customizing properties during drag
* and drop, such as whether or not to show the drop location,
* and which drop action to use.
* <p>
* Developers typically need not create instances of this
* class. Instead, they are something provided by the DnD
* implementation to certain methods in <code>TransferHandler</code>.
*
* @see #canImport(TransferHandler.TransferSupport)
* @see #importData(TransferHandler.TransferSupport)
* @since 1.6
*/
public final static class
TransferSupport {
private boolean
isDrop;
private
Component component;
private boolean
showDropLocationIsSet;
private boolean
showDropLocation;
private int
dropAction = -1;
/**
* The source is a {@code DropTargetDragEvent} or
* {@code DropTargetDropEvent} for drops,
* and a {@code Transferable} otherwise
*/
private
Object source;
private
DropLocation dropLocation;
/**
* Create a <code>TransferSupport</code> with <code>isDrop()</code>
* <code>true</code> for the given component, event, and index.
*
* @param component the target component
* @param event a <code>DropTargetEvent</code>
*/
private
TransferSupport(
Component component,
DropTargetEvent event) {
isDrop = true;
setDNDVariables(
component,
event);
}
/**
* Create a <code>TransferSupport</code> with <code>isDrop()</code>
* <code>false</code> for the given component and
* <code>Transferable</code>.
*
* @param component the target component
* @param transferable the transferable
* @throws NullPointerException if either parameter
* is <code>null</code>
*/
public
TransferSupport(
Component component,
Transferable transferable) {
if (
component == null) {
throw new
NullPointerException("component is null");
}
if (
transferable == null) {
throw new
NullPointerException("transferable is null");
}
isDrop = false;
this.
component =
component;
this.
source =
transferable;
}
/**
* Allows for a single instance to be reused during DnD.
*
* @param component the target component
* @param event a <code>DropTargetEvent</code>
*/
private void
setDNDVariables(
Component component,
DropTargetEvent event) {
assert
isDrop;
this.
component =
component;
this.
source =
event;
dropLocation = null;
dropAction = -1;
showDropLocationIsSet = false;
if (
source == null) {
return;
}
assert
source instanceof
DropTargetDragEvent ||
source instanceof
DropTargetDropEvent;
Point p =
source instanceof
DropTargetDragEvent
? ((
DropTargetDragEvent)
source).
getLocation()
: ((
DropTargetDropEvent)
source).
getLocation();
if (
SunToolkit.
isInstanceOf(
component, "javax.swing.text.JTextComponent")) {
dropLocation =
SwingAccessor.
getJTextComponentAccessor().
dropLocationForPoint((
JTextComponent)
component,
p);
} else if (
component instanceof
JComponent) {
dropLocation = ((
JComponent)
component).
dropLocationForPoint(
p);
}
/*
* The drop location may be null at this point if the component
* doesn't return custom drop locations. In this case, a point-only
* drop location will be created lazily when requested.
*/
}
/**
* Returns whether or not this <code>TransferSupport</code>
* represents a drop operation.
*
* @return <code>true</code> if this is a drop operation,
* <code>false</code> otherwise.
*/
public boolean
isDrop() {
return
isDrop;
}
/**
* Returns the target component of this transfer.
*
* @return the target component
*/
public
Component getComponent() {
return
component;
}
/**
* Checks that this is a drop and throws an
* {@code IllegalStateException} if it isn't.
*
* @throws IllegalStateException if {@code isDrop} is false.
*/
private void
assureIsDrop() {
if (!
isDrop) {
throw new
IllegalStateException("Not a drop");
}
}
/**
* Returns the current (non-{@code null}) drop location for the component,
* when this {@code TransferSupport} represents a drop.
* <p>
* Note: For components with built-in drop support, this location
* will be a subclass of {@code DropLocation} of the same type
* returned by that component's {@code getDropLocation} method.
* <p>
* This method is only for use with drag and drop transfers.
* Calling it when {@code isDrop()} is {@code false} results
* in an {@code IllegalStateException}.
*
* @return the drop location
* @throws IllegalStateException if this is not a drop
* @see #isDrop()
*/
public
DropLocation getDropLocation() {
assureIsDrop();
if (
dropLocation == null) {
/*
* component didn't give us a custom drop location,
* so lazily create a point-only location
*/
Point p =
source instanceof
DropTargetDragEvent
? ((
DropTargetDragEvent)
source).
getLocation()
: ((
DropTargetDropEvent)
source).
getLocation();
dropLocation = new
DropLocation(
p);
}
return
dropLocation;
}
/**
* Sets whether or not the drop location should be visually indicated
* for the transfer - which must represent a drop. This is applicable to
* those components that automatically
* show the drop location when appropriate during a drag and drop
* operation). By default, the drop location is shown only when the
* {@code TransferHandler} has said it can accept the import represented
* by this {@code TransferSupport}. With this method you can force the
* drop location to always be shown, or always not be shown.
* <p>
* This method is only for use with drag and drop transfers.
* Calling it when {@code isDrop()} is {@code false} results
* in an {@code IllegalStateException}.
*
* @param showDropLocation whether or not to indicate the drop location
* @throws IllegalStateException if this is not a drop
* @see #isDrop()
*/
public void
setShowDropLocation(boolean
showDropLocation) {
assureIsDrop();
this.
showDropLocation =
showDropLocation;
this.
showDropLocationIsSet = true;
}
/**
* Sets the drop action for the transfer - which must represent a drop
* - to the given action,
* instead of the default user drop action. The action must be
* supported by the source's drop actions, and must be one
* of {@code COPY}, {@code MOVE} or {@code LINK}.
* <p>
* This method is only for use with drag and drop transfers.
* Calling it when {@code isDrop()} is {@code false} results
* in an {@code IllegalStateException}.
*
* @param dropAction the drop action
* @throws IllegalStateException if this is not a drop
* @throws IllegalArgumentException if an invalid action is specified
* @see #getDropAction
* @see #getUserDropAction
* @see #getSourceDropActions
* @see #isDrop()
*/
public void
setDropAction(int
dropAction) {
assureIsDrop();
int
action =
dropAction &
getSourceDropActions();
if (!(
action ==
COPY ||
action ==
MOVE ||
action ==
LINK)) {
throw new
IllegalArgumentException("unsupported drop action: " +
dropAction);
}
this.
dropAction =
dropAction;
}
/**
* Returns the action chosen for the drop, when this
* {@code TransferSupport} represents a drop.
* <p>
* Unless explicitly chosen by way of {@code setDropAction},
* this returns the user drop action provided by
* {@code getUserDropAction}.
* <p>
* You may wish to query this in {@code TransferHandler}'s
* {@code importData} method to customize processing based
* on the action.
* <p>
* This method is only for use with drag and drop transfers.
* Calling it when {@code isDrop()} is {@code false} results
* in an {@code IllegalStateException}.
*
* @return the action chosen for the drop
* @throws IllegalStateException if this is not a drop
* @see #setDropAction
* @see #getUserDropAction
* @see #isDrop()
*/
public int
getDropAction() {
return
dropAction == -1 ?
getUserDropAction() :
dropAction;
}
/**
* Returns the user drop action for the drop, when this
* {@code TransferSupport} represents a drop.
* <p>
* The user drop action is chosen for a drop as described in the
* documentation for {@link java.awt.dnd.DropTargetDragEvent} and
* {@link java.awt.dnd.DropTargetDropEvent}. A different action
* may be chosen as the drop action by way of the {@code setDropAction}
* method.
* <p>
* You may wish to query this in {@code TransferHandler}'s
* {@code canImport} method when determining the suitability of a
* drop or when deciding on a drop action to explicitly choose.
* <p>
* This method is only for use with drag and drop transfers.
* Calling it when {@code isDrop()} is {@code false} results
* in an {@code IllegalStateException}.
*
* @return the user drop action
* @throws IllegalStateException if this is not a drop
* @see #setDropAction
* @see #getDropAction
* @see #isDrop()
*/
public int
getUserDropAction() {
assureIsDrop();
return (
source instanceof
DropTargetDragEvent)
? ((
DropTargetDragEvent)
source).
getDropAction()
: ((
DropTargetDropEvent)
source).
getDropAction();
}
/**
* Returns the drag source's supported drop actions, when this
* {@code TransferSupport} represents a drop.
* <p>
* The source actions represent the set of actions supported by the
* source of this transfer, and are represented as some bitwise-OR
* combination of {@code COPY}, {@code MOVE} and {@code LINK}.
* You may wish to query this in {@code TransferHandler}'s
* {@code canImport} method when determining the suitability of a drop
* or when deciding on a drop action to explicitly choose. To determine
* if a particular action is supported by the source, bitwise-AND
* the action with the source drop actions, and then compare the result
* against the original action. For example:
* <pre>
* boolean copySupported = (COPY & getSourceDropActions()) == COPY;
* </pre>
* <p>
* This method is only for use with drag and drop transfers.
* Calling it when {@code isDrop()} is {@code false} results
* in an {@code IllegalStateException}.
*
* @return the drag source's supported drop actions
* @throws IllegalStateException if this is not a drop
* @see #isDrop()
*/
public int
getSourceDropActions() {
assureIsDrop();
return (
source instanceof
DropTargetDragEvent)
? ((
DropTargetDragEvent)
source).
getSourceActions()
: ((
DropTargetDropEvent)
source).
getSourceActions();
}
/**
* Returns the data flavors for this transfer.
*
* @return the data flavors for this transfer
*/
public
DataFlavor[]
getDataFlavors() {
if (
isDrop) {
if (
source instanceof
DropTargetDragEvent) {
return ((
DropTargetDragEvent)
source).
getCurrentDataFlavors();
} else {
return ((
DropTargetDropEvent)
source).
getCurrentDataFlavors();
}
}
return ((
Transferable)
source).
getTransferDataFlavors();
}
/**
* Returns whether or not the given data flavor is supported.
*
* @param df the <code>DataFlavor</code> to test
* @return whether or not the given flavor is supported.
*/
public boolean
isDataFlavorSupported(
DataFlavor df) {
if (
isDrop) {
if (
source instanceof
DropTargetDragEvent) {
return ((
DropTargetDragEvent)
source).
isDataFlavorSupported(
df);
} else {
return ((
DropTargetDropEvent)
source).
isDataFlavorSupported(
df);
}
}
return ((
Transferable)
source).
isDataFlavorSupported(
df);
}
/**
* Returns the <code>Transferable</code> associated with this transfer.
* <p>
* Note: Unless it is necessary to fetch the <code>Transferable</code>
* directly, use one of the other methods on this class to inquire about
* the transfer. This may perform better than fetching the
* <code>Transferable</code> and asking it directly.
*
* @return the <code>Transferable</code> associated with this transfer
*/
public
Transferable getTransferable() {
if (
isDrop) {
if (
source instanceof
DropTargetDragEvent) {
return ((
DropTargetDragEvent)
source).
getTransferable();
} else {
return ((
DropTargetDropEvent)
source).
getTransferable();
}
}
return (
Transferable)
source;
}
}
/**
* Returns an {@code Action} that performs cut operations to the
* clipboard. When performed, this action operates on the {@code JComponent}
* source of the {@code ActionEvent} by invoking {@code exportToClipboard},
* with a {@code MOVE} action, on the component's {@code TransferHandler}.
*
* @return an {@code Action} for performing cuts to the clipboard
*/
public static
Action getCutAction() {
return
cutAction;
}
/**
* Returns an {@code Action} that performs copy operations to the
* clipboard. When performed, this action operates on the {@code JComponent}
* source of the {@code ActionEvent} by invoking {@code exportToClipboard},
* with a {@code COPY} action, on the component's {@code TransferHandler}.
*
* @return an {@code Action} for performing copies to the clipboard
*/
public static
Action getCopyAction() {
return
copyAction;
}
/**
* Returns an {@code Action} that performs paste operations from the
* clipboard. When performed, this action operates on the {@code JComponent}
* source of the {@code ActionEvent} by invoking {@code importData},
* with the clipboard contents, on the component's {@code TransferHandler}.
*
* @return an {@code Action} for performing pastes from the clipboard
*/
public static
Action getPasteAction() {
return
pasteAction;
}
/**
* Constructs a transfer handler that can transfer a Java Bean property
* from one component to another via the clipboard or a drag and drop
* operation.
*
* @param property the name of the property to transfer; this can
* be <code>null</code> if there is no property associated with the transfer
* handler (a subclass that performs some other kind of transfer, for example)
*/
public
TransferHandler(
String property) {
propertyName =
property;
}
/**
* Convenience constructor for subclasses.
*/
protected
TransferHandler() {
this(null);
}
/**
* image for the {@code startDrag} method
*
* @see java.awt.dnd.DragGestureEvent#startDrag(Cursor dragCursor, Image dragImage, Point imageOffset, Transferable transferable, DragSourceListener dsl)
*/
private
Image dragImage;
/**
* anchor offset for the {@code startDrag} method
*
* @see java.awt.dnd.DragGestureEvent#startDrag(Cursor dragCursor, Image dragImage, Point imageOffset, Transferable transferable, DragSourceListener dsl)
*/
private
Point dragImageOffset;
/**
* Sets the drag image parameter. The image has to be prepared
* for rendering by the moment of the call. The image is stored
* by reference because of some performance reasons.
*
* @param img an image to drag
*/
public void
setDragImage(
Image img) {
dragImage =
img;
}
/**
* Returns the drag image. If there is no image to drag,
* the returned value is {@code null}.
*
* @return the reference to the drag image
*/
public
Image getDragImage() {
return
dragImage;
}
/**
* Sets an anchor offset for the image to drag.
* It can not be {@code null}.
*
* @param p a {@code Point} object that corresponds
* to coordinates of an anchor offset of the image
* relative to the upper left corner of the image
*/
public void
setDragImageOffset(
Point p) {
dragImageOffset = new
Point(
p);
}
/**
* Returns an anchor offset for the image to drag.
*
* @return a {@code Point} object that corresponds
* to coordinates of an anchor offset of the image
* relative to the upper left corner of the image.
* The point {@code (0,0)} returns by default.
*/
public
Point getDragImageOffset() {
if (
dragImageOffset == null) {
return new
Point(0,0);
}
return new
Point(
dragImageOffset);
}
/**
* Causes the Swing drag support to be initiated. This is called by
* the various UI implementations in the <code>javax.swing.plaf.basic</code>
* package if the dragEnabled property is set on the component.
* This can be called by custom UI
* implementations to use the Swing drag support. This method can also be called
* by a Swing extension written as a subclass of <code>JComponent</code>
* to take advantage of the Swing drag support.
* <p>
* The transfer <em>will not necessarily</em> have been completed at the
* return of this call (i.e. the call does not block waiting for the drop).
* The transfer will take place through the Swing implementation of the
* <code>java.awt.dnd</code> mechanism, requiring no further effort
* from the developer. The <code>exportDone</code> method will be called
* when the transfer has completed.
*
* @param comp the component holding the data to be transferred;
* provided to enable sharing of <code>TransferHandler</code>s
* @param e the event that triggered the transfer
* @param action the transfer action initially requested;
* either {@code COPY}, {@code MOVE} or {@code LINK};
* the DnD system may change the action used during the
* course of the drag operation
*/
public void
exportAsDrag(
JComponent comp,
InputEvent e, int
action) {
int
srcActions =
getSourceActions(
comp);
// only mouse events supported for drag operations
if (!(
e instanceof
MouseEvent)
// only support known actions
|| !(
action ==
COPY ||
action ==
MOVE ||
action ==
LINK)
// only support valid source actions
|| (
srcActions &
action) == 0) {
action =
NONE;
}
if (
action !=
NONE && !
GraphicsEnvironment.
isHeadless()) {
if (
recognizer == null) {
recognizer = new
SwingDragGestureRecognizer(new
DragHandler());
}
recognizer.
gestured(
comp, (
MouseEvent)
e,
srcActions,
action);
} else {
exportDone(
comp, null,
NONE);
}
}
/**
* Causes a transfer from the given component to the
* given clipboard. This method is called by the default cut and
* copy actions registered in a component's action map.
* <p>
* The transfer will take place using the <code>java.awt.datatransfer</code>
* mechanism, requiring no further effort from the developer. Any data
* transfer <em>will</em> be complete and the <code>exportDone</code>
* method will be called with the action that occurred, before this method
* returns. Should the clipboard be unavailable when attempting to place
* data on it, the <code>IllegalStateException</code> thrown by
* {@link Clipboard#setContents(Transferable, ClipboardOwner)} will
* be propagated through this method. However,
* <code>exportDone</code> will first be called with an action
* of <code>NONE</code> for consistency.
*
* @param comp the component holding the data to be transferred;
* provided to enable sharing of <code>TransferHandler</code>s
* @param clip the clipboard to transfer the data into
* @param action the transfer action requested; this should
* be a value of either <code>COPY</code> or <code>MOVE</code>;
* the operation performed is the intersection of the transfer
* capabilities given by getSourceActions and the requested action;
* the intersection may result in an action of <code>NONE</code>
* if the requested action isn't supported
* @throws IllegalStateException if the clipboard is currently unavailable
* @see Clipboard#setContents(Transferable, ClipboardOwner)
*/
public void
exportToClipboard(
JComponent comp,
Clipboard clip, int
action)
throws
IllegalStateException {
if ((
action ==
COPY ||
action ==
MOVE)
&& (
getSourceActions(
comp) &
action) != 0) {
Transferable t =
createTransferable(
comp);
if (
t != null) {
try {
clip.
setContents(
t, null);
exportDone(
comp,
t,
action);
return;
} catch (
IllegalStateException ise) {
exportDone(
comp,
t,
NONE);
throw
ise;
}
}
}
exportDone(
comp, null,
NONE);
}
/**
* Causes a transfer to occur from a clipboard or a drag and
* drop operation. The <code>Transferable</code> to be
* imported and the component to transfer to are contained
* within the <code>TransferSupport</code>.
* <p>
* While the drag and drop implementation calls {@code canImport}
* to determine the suitability of a transfer before calling this
* method, the implementation of paste does not. As such, it cannot
* be assumed that the transfer is acceptable upon a call to
* this method for paste. It is recommended that {@code canImport} be
* explicitly called to cover this case.
* <p>
* Note: The <code>TransferSupport</code> object passed to this method
* is only valid for the duration of the method call. It is undefined
* what values it may contain after this method returns.
*
* @param support the object containing the details of
* the transfer, not <code>null</code>.
* @return true if the data was inserted into the component,
* false otherwise
* @throws NullPointerException if <code>support</code> is {@code null}
* @see #canImport(TransferHandler.TransferSupport)
* @since 1.6
*/
public boolean
importData(
TransferSupport support) {
return
support.
getComponent() instanceof
JComponent
?
importData((
JComponent)
support.
getComponent(),
support.
getTransferable())
: false;
}
/**
* Causes a transfer to a component from a clipboard or a
* DND drop operation. The <code>Transferable</code> represents
* the data to be imported into the component.
* <p>
* Note: Swing now calls the newer version of <code>importData</code>
* that takes a <code>TransferSupport</code>, which in turn calls this
* method (if the component in the {@code TransferSupport} is a
* {@code JComponent}). Developers are encouraged to call and override the
* newer version as it provides more information (and is the only
* version that supports use with a {@code TransferHandler} set directly
* on a {@code JFrame} or other non-{@code JComponent}).
*
* @param comp the component to receive the transfer;
* provided to enable sharing of <code>TransferHandler</code>s
* @param t the data to import
* @return true if the data was inserted into the component, false otherwise
* @see #importData(TransferHandler.TransferSupport)
*/
public boolean
importData(
JComponent comp,
Transferable t) {
PropertyDescriptor prop =
getPropertyDescriptor(
comp);
if (
prop != null) {
Method writer =
prop.
getWriteMethod();
if (
writer == null) {
// read-only property. ignore
return false;
}
Class<?>[]
params =
writer.
getParameterTypes();
if (
params.length != 1) {
// zero or more than one argument, ignore
return false;
}
DataFlavor flavor =
getPropertyDataFlavor(
params[0],
t.
getTransferDataFlavors());
if (
flavor != null) {
try {
Object value =
t.
getTransferData(
flavor);
Object[]
args = {
value };
MethodUtil.
invoke(
writer,
comp,
args);
return true;
} catch (
Exception ex) {
System.
err.
println("Invocation failed");
// invocation code
}
}
}
return false;
}
/**
* This method is called repeatedly during a drag and drop operation
* to allow the developer to configure properties of, and to return
* the acceptability of transfers; with a return value of {@code true}
* indicating that the transfer represented by the given
* {@code TransferSupport} (which contains all of the details of the
* transfer) is acceptable at the current time, and a value of {@code false}
* rejecting the transfer.
* <p>
* For those components that automatically display a drop location during
* drag and drop, accepting the transfer, by default, tells them to show
* the drop location. This can be changed by calling
* {@code setShowDropLocation} on the {@code TransferSupport}.
* <p>
* By default, when the transfer is accepted, the chosen drop action is that
* picked by the user via their drag gesture. The developer can override
* this and choose a different action, from the supported source
* actions, by calling {@code setDropAction} on the {@code TransferSupport}.
* <p>
* On every call to {@code canImport}, the {@code TransferSupport} contains
* fresh state. As such, any properties set on it must be set on every
* call. Upon a drop, {@code canImport} is called one final time before
* calling into {@code importData}. Any state set on the
* {@code TransferSupport} during that last call will be available in
* {@code importData}.
* <p>
* This method is not called internally in response to paste operations.
* As such, it is recommended that implementations of {@code importData}
* explicitly call this method for such cases and that this method
* be prepared to return the suitability of paste operations as well.
* <p>
* Note: The <code>TransferSupport</code> object passed to this method
* is only valid for the duration of the method call. It is undefined
* what values it may contain after this method returns.
*
* @param support the object containing the details of
* the transfer, not <code>null</code>.
* @return <code>true</code> if the import can happen,
* <code>false</code> otherwise
* @throws NullPointerException if <code>support</code> is {@code null}
* @see #importData(TransferHandler.TransferSupport)
* @see javax.swing.TransferHandler.TransferSupport#setShowDropLocation
* @see javax.swing.TransferHandler.TransferSupport#setDropAction
* @since 1.6
*/
public boolean
canImport(
TransferSupport support) {
return
support.
getComponent() instanceof
JComponent
?
canImport((
JComponent)
support.
getComponent(),
support.
getDataFlavors())
: false;
}
/**
* Indicates whether a component will accept an import of the given
* set of data flavors prior to actually attempting to import it.
* <p>
* Note: Swing now calls the newer version of <code>canImport</code>
* that takes a <code>TransferSupport</code>, which in turn calls this
* method (only if the component in the {@code TransferSupport} is a
* {@code JComponent}). Developers are encouraged to call and override the
* newer version as it provides more information (and is the only
* version that supports use with a {@code TransferHandler} set directly
* on a {@code JFrame} or other non-{@code JComponent}).
*
* @param comp the component to receive the transfer;
* provided to enable sharing of <code>TransferHandler</code>s
* @param transferFlavors the data formats available
* @return true if the data can be inserted into the component, false otherwise
* @see #canImport(TransferHandler.TransferSupport)
*/
public boolean
canImport(
JComponent comp,
DataFlavor[]
transferFlavors) {
PropertyDescriptor prop =
getPropertyDescriptor(
comp);
if (
prop != null) {
Method writer =
prop.
getWriteMethod();
if (
writer == null) {
// read-only property. ignore
return false;
}
Class<?>[]
params =
writer.
getParameterTypes();
if (
params.length != 1) {
// zero or more than one argument, ignore
return false;
}
DataFlavor flavor =
getPropertyDataFlavor(
params[0],
transferFlavors);
if (
flavor != null) {
return true;
}
}
return false;
}
/**
* Returns the type of transfer actions supported by the source;
* any bitwise-OR combination of {@code COPY}, {@code MOVE}
* and {@code LINK}.
* <p>
* Some models are not mutable, so a transfer operation of {@code MOVE}
* should not be advertised in that case. Returning {@code NONE}
* disables transfers from the component.
*
* @param c the component holding the data to be transferred;
* provided to enable sharing of <code>TransferHandler</code>s
* @return {@code COPY} if the transfer property can be found,
* otherwise returns <code>NONE</code>
*/
public int
getSourceActions(
JComponent c) {
PropertyDescriptor prop =
getPropertyDescriptor(
c);
if (
prop != null) {
return
COPY;
}
return
NONE;
}
/**
* Returns an object that establishes the look of a transfer. This is
* useful for both providing feedback while performing a drag operation and for
* representing the transfer in a clipboard implementation that has a visual
* appearance. The implementation of the <code>Icon</code> interface should
* not alter the graphics clip or alpha level.
* The icon implementation need not be rectangular or paint all of the
* bounding rectangle and logic that calls the icons paint method should
* not assume the all bits are painted. <code>null</code> is a valid return value
* for this method and indicates there is no visual representation provided.
* In that case, the calling logic is free to represent the
* transferable however it wants.
* <p>
* The default Swing logic will not do an alpha blended drag animation if
* the return is <code>null</code>.
*
* @param t the data to be transferred; this value is expected to have been
* created by the <code>createTransferable</code> method
* @return <code>null</code>, indicating
* there is no default visual representation
*/
public
Icon getVisualRepresentation(
Transferable t) {
return null;
}
/**
* Creates a <code>Transferable</code> to use as the source for
* a data transfer. Returns the representation of the data to
* be transferred, or <code>null</code> if the component's
* property is <code>null</code>
*
* @param c the component holding the data to be transferred;
* provided to enable sharing of <code>TransferHandler</code>s
* @return the representation of the data to be transferred, or
* <code>null</code> if the property associated with <code>c</code>
* is <code>null</code>
*
*/
protected
Transferable createTransferable(
JComponent c) {
PropertyDescriptor property =
getPropertyDescriptor(
c);
if (
property != null) {
return new
PropertyTransferable(
property,
c);
}
return null;
}
/**
* Invoked after data has been exported. This method should remove
* the data that was transferred if the action was <code>MOVE</code>.
* <p>
* This method is implemented to do nothing since <code>MOVE</code>
* is not a supported action of this implementation
* (<code>getSourceActions</code> does not include <code>MOVE</code>).
*
* @param source the component that was the source of the data
* @param data The data that was transferred or possibly null
* if the action is <code>NONE</code>.
* @param action the actual action that was performed
*/
protected void
exportDone(
JComponent source,
Transferable data, int
action) {
}
/**
* Fetches the property descriptor for the property assigned to this transfer
* handler on the given component (transfer handler may be shared). This
* returns <code>null</code> if the property descriptor can't be found
* or there is an error attempting to fetch the property descriptor.
*/
private
PropertyDescriptor getPropertyDescriptor(
JComponent comp) {
if (
propertyName == null) {
return null;
}
Class<?>
k =
comp.
getClass();
BeanInfo bi;
try {
bi =
Introspector.
getBeanInfo(
k);
} catch (
IntrospectionException ex) {
return null;
}
PropertyDescriptor props[] =
bi.
getPropertyDescriptors();
for (int
i=0;
i <
props.length;
i++) {
if (
propertyName.
equals(
props[
i].
getName())) {
Method reader =
props[
i].
getReadMethod();
if (
reader != null) {
Class<?>[]
params =
reader.
getParameterTypes();
if (
params == null ||
params.length == 0) {
// found the desired descriptor
return
props[
i];
}
}
}
}
return null;
}
/**
* Fetches the data flavor from the array of possible flavors that
* has data of the type represented by property type. Null is
* returned if there is no match.
*/
private
DataFlavor getPropertyDataFlavor(
Class<?>
k,
DataFlavor[]
flavors) {
for(int
i = 0;
i <
flavors.length;
i++) {
DataFlavor flavor =
flavors[
i];
if ("application".
equals(
flavor.
getPrimaryType()) &&
"x-java-jvm-local-objectref".
equals(
flavor.
getSubType()) &&
k.
isAssignableFrom(
flavor.
getRepresentationClass())) {
return
flavor;
}
}
return null;
}
private
String propertyName;
private static
SwingDragGestureRecognizer recognizer = null;
private static
DropTargetListener getDropTargetListener() {
synchronized(
DropHandler.class) {
DropHandler handler =
(
DropHandler)
AppContext.
getAppContext().
get(
DropHandler.class);
if (
handler == null) {
handler = new
DropHandler();
AppContext.
getAppContext().
put(
DropHandler.class,
handler);
}
return
handler;
}
}
static class
PropertyTransferable implements
Transferable {
PropertyTransferable(
PropertyDescriptor p,
JComponent c) {
property =
p;
component =
c;
}
// --- Transferable methods ----------------------------------------------
/**
* Returns an array of <code>DataFlavor</code> objects indicating the flavors the data
* can be provided in. The array should be ordered according to preference
* for providing the data (from most richly descriptive to least descriptive).
* @return an array of data flavors in which this data can be transferred
*/
public
DataFlavor[]
getTransferDataFlavors() {
DataFlavor[]
flavors = new
DataFlavor[1];
Class<?>
propertyType =
property.
getPropertyType();
String mimeType =
DataFlavor.
javaJVMLocalObjectMimeType + ";class=" +
propertyType.
getName();
try {
flavors[0] = new
DataFlavor(
mimeType);
} catch (
ClassNotFoundException cnfe) {
flavors = new
DataFlavor[0];
}
return
flavors;
}
/**
* Returns whether the specified data flavor is supported for
* this object.
* @param flavor the requested flavor for the data
* @return true if this <code>DataFlavor</code> is supported,
* otherwise false
*/
public boolean
isDataFlavorSupported(
DataFlavor flavor) {
Class<?>
propertyType =
property.
getPropertyType();
if ("application".
equals(
flavor.
getPrimaryType()) &&
"x-java-jvm-local-objectref".
equals(
flavor.
getSubType()) &&
flavor.
getRepresentationClass().
isAssignableFrom(
propertyType)) {
return true;
}
return false;
}
/**
* Returns an object which represents the data to be transferred. The class
* of the object returned is defined by the representation class of the flavor.
*
* @param flavor the requested flavor for the data
* @see DataFlavor#getRepresentationClass
* @exception IOException if the data is no longer available
* in the requested flavor.
* @exception UnsupportedFlavorException if the requested data flavor is
* not supported.
*/
public
Object getTransferData(
DataFlavor flavor) throws
UnsupportedFlavorException,
IOException {
if (!
isDataFlavorSupported(
flavor)) {
throw new
UnsupportedFlavorException(
flavor);
}
Method reader =
property.
getReadMethod();
Object value = null;
try {
value =
MethodUtil.
invoke(
reader,
component, (
Object[])null);
} catch (
Exception ex) {
throw new
IOException("Property read failed: " +
property.
getName());
}
return
value;
}
JComponent component;
PropertyDescriptor property;
}
/**
* This is the default drop target for drag and drop operations if
* one isn't provided by the developer. <code>DropTarget</code>
* only supports one <code>DropTargetListener</code> and doesn't
* function properly if it isn't set.
* This class sets the one listener as the linkage of drop handling
* to the <code>TransferHandler</code>, and adds support for
* additional listeners which some of the <code>ComponentUI</code>
* implementations install to manipulate a drop insertion location.
*/
static class
SwingDropTarget extends
DropTarget implements
UIResource {
SwingDropTarget(
Component c) {
super(
c,
COPY_OR_MOVE |
LINK, null);
try {
// addDropTargetListener is overridden
// we specifically need to add to the superclass
super.addDropTargetListener(
getDropTargetListener());
} catch (
TooManyListenersException tmle) {}
}
public void
addDropTargetListener(
DropTargetListener dtl) throws
TooManyListenersException {
// Since the super class only supports one DropTargetListener,
// and we add one from the constructor, we always add to the
// extended list.
if (
listenerList == null) {
listenerList = new
EventListenerList();
}
listenerList.
add(
DropTargetListener.class,
dtl);
}
public void
removeDropTargetListener(
DropTargetListener dtl) {
if (
listenerList != null) {
listenerList.
remove(
DropTargetListener.class,
dtl);
}
}
// --- DropTargetListener methods (multicast) --------------------------
public void
dragEnter(
DropTargetDragEvent e) {
super.dragEnter(
e);
if (
listenerList != null) {
Object[]
listeners =
listenerList.
getListenerList();
for (int
i =
listeners.length-2;
i>=0;
i-=2) {
if (
listeners[
i]==
DropTargetListener.class) {
((
DropTargetListener)
listeners[
i+1]).
dragEnter(
e);
}
}
}
}
public void
dragOver(
DropTargetDragEvent e) {
super.dragOver(
e);
if (
listenerList != null) {
Object[]
listeners =
listenerList.
getListenerList();
for (int
i =
listeners.length-2;
i>=0;
i-=2) {
if (
listeners[
i]==
DropTargetListener.class) {
((
DropTargetListener)
listeners[
i+1]).
dragOver(
e);
}
}
}
}
public void
dragExit(
DropTargetEvent e) {
super.dragExit(
e);
if (
listenerList != null) {
Object[]
listeners =
listenerList.
getListenerList();
for (int
i =
listeners.length-2;
i>=0;
i-=2) {
if (
listeners[
i]==
DropTargetListener.class) {
((
DropTargetListener)
listeners[
i+1]).
dragExit(
e);
}
}
}
if (!
isActive()) {
// If the Drop target is inactive the dragExit will not be dispatched to the dtListener,
// so make sure that we clean up the dtListener anyway.
DropTargetListener dtListener =
getDropTargetListener();
if (
dtListener != null &&
dtListener instanceof
DropHandler) {
((
DropHandler)
dtListener).
cleanup(false);
}
}
}
public void
drop(
DropTargetDropEvent e) {
super.drop(
e);
if (
listenerList != null) {
Object[]
listeners =
listenerList.
getListenerList();
for (int
i =
listeners.length-2;
i>=0;
i-=2) {
if (
listeners[
i]==
DropTargetListener.class) {
((
DropTargetListener)
listeners[
i+1]).
drop(
e);
}
}
}
}
public void
dropActionChanged(
DropTargetDragEvent e) {
super.dropActionChanged(
e);
if (
listenerList != null) {
Object[]
listeners =
listenerList.
getListenerList();
for (int
i =
listeners.length-2;
i>=0;
i-=2) {
if (
listeners[
i]==
DropTargetListener.class) {
((
DropTargetListener)
listeners[
i+1]).
dropActionChanged(
e);
}
}
}
}
private
EventListenerList listenerList;
}
private static class
DropHandler implements
DropTargetListener,
Serializable,
ActionListener {
private
Timer timer;
private
Point lastPosition;
private
Rectangle outer = new
Rectangle();
private
Rectangle inner = new
Rectangle();
private int
hysteresis = 10;
private
Component component;
private
Object state;
private
TransferSupport support =
new
TransferSupport(null, (
DropTargetEvent)null);
private static final int
AUTOSCROLL_INSET = 10;
/**
* Update the geometry of the autoscroll region. The geometry is
* maintained as a pair of rectangles. The region can cause
* a scroll if the pointer sits inside it for the duration of the
* timer. The region that causes the timer countdown is the area
* between the two rectangles.
* <p>
* This is implemented to use the visible area of the component
* as the outer rectangle, and the insets are fixed at 10. Should
* the component be smaller than a total of 20 in any direction,
* autoscroll will not occur in that direction.
*/
private void
updateAutoscrollRegion(
JComponent c) {
// compute the outer
Rectangle visible =
c.
getVisibleRect();
outer.
setBounds(
visible.
x,
visible.
y,
visible.
width,
visible.
height);
// compute the insets
Insets i = new
Insets(0, 0, 0, 0);
if (
c instanceof
Scrollable) {
int
minSize = 2 *
AUTOSCROLL_INSET;
if (
visible.
width >=
minSize) {
i.
left =
i.
right =
AUTOSCROLL_INSET;
}
if (
visible.
height >=
minSize) {
i.
top =
i.
bottom =
AUTOSCROLL_INSET;
}
}
// set the inner from the insets
inner.
setBounds(
visible.
x +
i.
left,
visible.
y +
i.
top,
visible.
width - (
i.
left +
i.
right),
visible.
height - (
i.
top +
i.
bottom));
}
/**
* Perform an autoscroll operation. This is implemented to scroll by the
* unit increment of the Scrollable using scrollRectToVisible. If the
* cursor is in a corner of the autoscroll region, more than one axis will
* scroll.
*/
private void
autoscroll(
JComponent c,
Point pos) {
if (
c instanceof
Scrollable) {
Scrollable s = (
Scrollable)
c;
if (
pos.
y <
inner.
y) {
// scroll upward
int
dy =
s.
getScrollableUnitIncrement(
outer,
SwingConstants.
VERTICAL, -1);
Rectangle r = new
Rectangle(
inner.
x,
outer.
y -
dy,
inner.
width,
dy);
c.
scrollRectToVisible(
r);
} else if (
pos.
y > (
inner.
y +
inner.
height)) {
// scroll downard
int
dy =
s.
getScrollableUnitIncrement(
outer,
SwingConstants.
VERTICAL, 1);
Rectangle r = new
Rectangle(
inner.
x,
outer.
y +
outer.
height,
inner.
width,
dy);
c.
scrollRectToVisible(
r);
}
if (
pos.
x <
inner.
x) {
// scroll left
int
dx =
s.
getScrollableUnitIncrement(
outer,
SwingConstants.
HORIZONTAL, -1);
Rectangle r = new
Rectangle(
outer.
x -
dx,
inner.
y,
dx,
inner.
height);
c.
scrollRectToVisible(
r);
} else if (
pos.
x > (
inner.
x +
inner.
width)) {
// scroll right
int
dx =
s.
getScrollableUnitIncrement(
outer,
SwingConstants.
HORIZONTAL, 1);
Rectangle r = new
Rectangle(
outer.
x +
outer.
width,
inner.
y,
dx,
inner.
height);
c.
scrollRectToVisible(
r);
}
}
}
/**
* Initializes the internal properties if they haven't been already
* inited. This is done lazily to avoid loading of desktop properties.
*/
private void
initPropertiesIfNecessary() {
if (
timer == null) {
Toolkit t =
Toolkit.
getDefaultToolkit();
Integer prop;
prop = (
Integer)
t.
getDesktopProperty("DnD.Autoscroll.interval");
timer = new
Timer(
prop == null ? 100 :
prop.
intValue(), this);
prop = (
Integer)
t.
getDesktopProperty("DnD.Autoscroll.initialDelay");
timer.
setInitialDelay(
prop == null ? 100 :
prop.
intValue());
prop = (
Integer)
t.
getDesktopProperty("DnD.Autoscroll.cursorHysteresis");
if (
prop != null) {
hysteresis =
prop.
intValue();
}
}
}
/**
* The timer fired, perform autoscroll if the pointer is within the
* autoscroll region.
* <P>
* @param e the <code>ActionEvent</code>
*/
public void
actionPerformed(
ActionEvent e) {
updateAutoscrollRegion((
JComponent)
component);
if (
outer.
contains(
lastPosition) && !
inner.
contains(
lastPosition)) {
autoscroll((
JComponent)
component,
lastPosition);
}
}
// --- DropTargetListener methods -----------------------------------
private void
setComponentDropLocation(
TransferSupport support,
boolean
forDrop) {
DropLocation dropLocation = (
support == null)
? null
:
support.
getDropLocation();
if (
SunToolkit.
isInstanceOf(
component, "javax.swing.text.JTextComponent")) {
state =
SwingAccessor.
getJTextComponentAccessor().
setDropLocation((
JTextComponent)
component,
dropLocation,
state,
forDrop);
} else if (
component instanceof
JComponent) {
state = ((
JComponent)
component).
setDropLocation(
dropLocation,
state,
forDrop);
}
}
private void
handleDrag(
DropTargetDragEvent e) {
TransferHandler importer =
((
HasGetTransferHandler)
component).
getTransferHandler();
if (
importer == null) {
e.
rejectDrag();
setComponentDropLocation(null, false);
return;
}
support.
setDNDVariables(
component,
e);
boolean
canImport =
importer.
canImport(
support);
if (
canImport) {
e.
acceptDrag(
support.
getDropAction());
} else {
e.
rejectDrag();
}
boolean
showLocation =
support.
showDropLocationIsSet ?
support.
showDropLocation :
canImport;
setComponentDropLocation(
showLocation ?
support : null, false);
}
public void
dragEnter(
DropTargetDragEvent e) {
state = null;
component =
e.
getDropTargetContext().
getComponent();
handleDrag(
e);
if (
component instanceof
JComponent) {
lastPosition =
e.
getLocation();
updateAutoscrollRegion((
JComponent)
component);
initPropertiesIfNecessary();
}
}
public void
dragOver(
DropTargetDragEvent e) {
handleDrag(
e);
if (!(
component instanceof
JComponent)) {
return;
}
Point p =
e.
getLocation();
if (
Math.
abs(
p.
x -
lastPosition.
x) >
hysteresis
||
Math.
abs(
p.
y -
lastPosition.
y) >
hysteresis) {
// no autoscroll
if (
timer.
isRunning())
timer.
stop();
} else {
if (!
timer.
isRunning())
timer.
start();
}
lastPosition =
p;
}
public void
dragExit(
DropTargetEvent e) {
cleanup(false);
}
public void
drop(
DropTargetDropEvent e) {
TransferHandler importer =
((
HasGetTransferHandler)
component).
getTransferHandler();
if (
importer == null) {
e.
rejectDrop();
cleanup(false);
return;
}
support.
setDNDVariables(
component,
e);
boolean
canImport =
importer.
canImport(
support);
if (
canImport) {
e.
acceptDrop(
support.
getDropAction());
boolean
showLocation =
support.
showDropLocationIsSet ?
support.
showDropLocation :
canImport;
setComponentDropLocation(
showLocation ?
support : null, false);
boolean
success;
try {
success =
importer.
importData(
support);
} catch (
RuntimeException re) {
success = false;
}
e.
dropComplete(
success);
cleanup(
success);
} else {
e.
rejectDrop();
cleanup(false);
}
}
public void
dropActionChanged(
DropTargetDragEvent e) {
/*
* Work-around for Linux bug where dropActionChanged
* is called before dragEnter.
*/
if (
component == null) {
return;
}
handleDrag(
e);
}
private void
cleanup(boolean
forDrop) {
setComponentDropLocation(null,
forDrop);
if (
component instanceof
JComponent) {
((
JComponent)
component).
dndDone();
}
if (
timer != null) {
timer.
stop();
}
state = null;
component = null;
lastPosition = null;
}
}
/**
* This is the default drag handler for drag and drop operations that
* use the <code>TransferHandler</code>.
*/
private static class
DragHandler implements
DragGestureListener,
DragSourceListener {
private boolean
scrolls;
// --- DragGestureListener methods -----------------------------------
/**
* a Drag gesture has been recognized
*/
public void
dragGestureRecognized(
DragGestureEvent dge) {
JComponent c = (
JComponent)
dge.
getComponent();
TransferHandler th =
c.
getTransferHandler();
Transferable t =
th.
createTransferable(
c);
if (
t != null) {
scrolls =
c.
getAutoscrolls();
c.
setAutoscrolls(false);
try {
Image im =
th.
getDragImage();
if (
im == null) {
dge.
startDrag(null,
t, this);
} else {
dge.
startDrag(null,
im,
th.
getDragImageOffset(),
t, this);
}
return;
} catch (
RuntimeException re) {
c.
setAutoscrolls(
scrolls);
}
}
th.
exportDone(
c,
t,
NONE);
}
// --- DragSourceListener methods -----------------------------------
/**
* as the hotspot enters a platform dependent drop site
*/
public void
dragEnter(
DragSourceDragEvent dsde) {
}
/**
* as the hotspot moves over a platform dependent drop site
*/
public void
dragOver(
DragSourceDragEvent dsde) {
}
/**
* as the hotspot exits a platform dependent drop site
*/
public void
dragExit(
DragSourceEvent dsde) {
}
/**
* as the operation completes
*/
public void
dragDropEnd(
DragSourceDropEvent dsde) {
DragSourceContext dsc =
dsde.
getDragSourceContext();
JComponent c = (
JComponent)
dsc.
getComponent();
if (
dsde.
getDropSuccess()) {
c.
getTransferHandler().
exportDone(
c,
dsc.
getTransferable(),
dsde.
getDropAction());
} else {
c.
getTransferHandler().
exportDone(
c,
dsc.
getTransferable(),
NONE);
}
c.
setAutoscrolls(
scrolls);
}
public void
dropActionChanged(
DragSourceDragEvent dsde) {
}
}
private static class
SwingDragGestureRecognizer extends
DragGestureRecognizer {
SwingDragGestureRecognizer(
DragGestureListener dgl) {
super(
DragSource.
getDefaultDragSource(), null,
NONE,
dgl);
}
void
gestured(
JComponent c,
MouseEvent e, int
srcActions, int
action) {
setComponent(
c);
setSourceActions(
srcActions);
appendEvent(
e);
fireDragGestureRecognized(
action,
e.
getPoint());
}
/**
* register this DragGestureRecognizer's Listeners with the Component
*/
protected void
registerListeners() {
}
/**
* unregister this DragGestureRecognizer's Listeners with the Component
*
* subclasses must override this method
*/
protected void
unregisterListeners() {
}
}
static final
Action cutAction = new
TransferAction("cut");
static final
Action copyAction = new
TransferAction("copy");
static final
Action pasteAction = new
TransferAction("paste");
static class
TransferAction extends
UIAction implements
UIResource {
TransferAction(
String name) {
super(
name);
}
public boolean
isEnabled(
Object sender) {
if (
sender instanceof
JComponent
&& ((
JComponent)
sender).
getTransferHandler() == null) {
return false;
}
return true;
}
private static final
JavaSecurityAccess javaSecurityAccess =
SharedSecrets.
getJavaSecurityAccess();
public void
actionPerformed(final
ActionEvent e) {
final
Object src =
e.
getSource();
final
PrivilegedAction<
Void>
action = new
PrivilegedAction<
Void>() {
public
Void run() {
actionPerformedImpl(
e);
return null;
}
};
final
AccessControlContext stack =
AccessController.
getContext();
final
AccessControlContext srcAcc =
AWTAccessor.
getComponentAccessor().
getAccessControlContext((
Component)
src);
final
AccessControlContext eventAcc =
AWTAccessor.
getAWTEventAccessor().
getAccessControlContext(
e);
if (
srcAcc == null) {
javaSecurityAccess.
doIntersectionPrivilege(
action,
stack,
eventAcc);
} else {
javaSecurityAccess.
doIntersectionPrivilege(
new
PrivilegedAction<
Void>() {
public
Void run() {
javaSecurityAccess.
doIntersectionPrivilege(
action,
eventAcc);
return null;
}
},
stack,
srcAcc);
}
}
private void
actionPerformedImpl(
ActionEvent e) {
Object src =
e.
getSource();
if (
src instanceof
JComponent) {
JComponent c = (
JComponent)
src;
TransferHandler th =
c.
getTransferHandler();
Clipboard clipboard =
getClipboard(
c);
String name = (
String)
getValue(
Action.
NAME);
Transferable trans = null;
// any of these calls may throw IllegalStateException
try {
if ((
clipboard != null) && (
th != null) && (
name != null)) {
if ("cut".
equals(
name)) {
th.
exportToClipboard(
c,
clipboard,
MOVE);
} else if ("copy".
equals(
name)) {
th.
exportToClipboard(
c,
clipboard,
COPY);
} else if ("paste".
equals(
name)) {
trans =
clipboard.
getContents(null);
}
}
} catch (
IllegalStateException ise) {
// clipboard was unavailable
UIManager.
getLookAndFeel().
provideErrorFeedback(
c);
return;
}
// this is a paste action, import data into the component
if (
trans != null) {
th.
importData(new
TransferSupport(
c,
trans));
}
}
}
/**
* Returns the clipboard to use for cut/copy/paste.
*/
private
Clipboard getClipboard(
JComponent c) {
if (
SwingUtilities2.
canAccessSystemClipboard()) {
return
c.
getToolkit().
getSystemClipboard();
}
Clipboard clipboard = (
Clipboard)sun.awt.
AppContext.
getAppContext().
get(
SandboxClipboardKey);
if (
clipboard == null) {
clipboard = new
Clipboard("Sandboxed Component Clipboard");
sun.awt.
AppContext.
getAppContext().
put(
SandboxClipboardKey,
clipboard);
}
return
clipboard;
}
/**
* Key used in app context to lookup Clipboard to use if access to
* System clipboard is denied.
*/
private static
Object SandboxClipboardKey = new
Object();
}
}