* To use this class, construct a new FileDrop by passing * it the target component and a Listener to receive notification * when file(s) have been dropped. Here is an example: *
*
* JPanel myPanel = new JPanel();
* new FileDrop( myPanel, new FileDrop.Listener()
* { public void filesDropped( java.io.File[] files )
* {
* // handle file drop
* ...
* } // end filesDropped
* }); // end FileDrop.Listener
*
*
* You can specify the border that will appear when files are being dragged by * calling the constructor with a {@link javax.swing.border.Border}. Only * JComponents will show any indication with a border. *
* You can turn on some debugging features by passing a PrintStream * object (such as System.out) into the full constructor. A null * value will result in no extra debugging information being output. * *
I'm releasing this code into the Public Domain. Enjoy. *
*Original author: Robert Harder, rharder@usa.net
*2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added.
* * @author Robert Harder * @author rharder@users.sf.net * @version 1.0.1 * @since 1231 */ public class FileDrop { // CHECKSTYLE.ON: HideUtilityClassConstructor private Border normalBorder; private DropTargetListener dropListener; // Default border color private static Color defaultBorderColor = new Color(0f, 0f, 1f, 0.25f); /** * Constructor for JOSM file drop * @param c The drop target */ public FileDrop(final Component c) { this( c, // Drop target BorderFactory.createMatteBorder(2, 2, 2, 2, defaultBorderColor), // Drag border true, // Recursive new FileDrop.Listener() { @Override public void filesDropped(File[] files) { // start asynchronous loading of files OpenFileAction.OpenFileTask task = new OpenFileAction.OpenFileTask(Arrays.asList(files), null); task.setRecordHistory(true); Main.worker.submit(task); } } ); } /** * Full constructor with a specified border and debugging optionally turned on. * With Debugging turned on, more status messages will be displayed to * out. A common way to use this constructor is with * System.out or System.err. A null value for * the parameter out will result in no debugging output. * * @param c Component on which files will be dropped. * @param dragBorder Border to use on JComponent when dragging occurs. * @param recursive Recursively set children as drop targets. * @param listener Listens for filesDropped. */ public FileDrop( final Component c, final Border dragBorder, final boolean recursive, final Listener listener) { // Make a drop listener dropListener = new DropListener(listener, dragBorder, c); // Make the component (and possibly children) drop targets makeDropTarget(c, recursive); } // BEGIN 2007-09-12 Nathan Blomquist -- Linux (KDE/Gnome) support added. private static final String ZERO_CHAR_STRING = Character.toString((char) 0); private static File[] createFileArray(BufferedReader bReader) { try { List
* public class MyClass implements FileDrop.Listener
* ...
* public void filesDropped( java.io.File[] files )
* {
* ...
* } // end filesDropped
* ...
*
*/
public interface Listener {
/**
* This method is called when files have been successfully dropped.
*
* @param files An array of Files that were dropped.
*/
void filesDropped(File[] files);
}
/* ******** I N N E R C L A S S ******** */
/**
* At last an easy way to encapsulate your custom objects for dragging and dropping
* in your Java programs!
* When you need to create a {@link java.awt.datatransfer.Transferable} object,
* use this class to wrap your object.
* For example:
*
* ...
* MyCoolClass myObj = new MyCoolClass();
* Transferable xfer = new TransferableObject( myObj );
* ...
*
* ...
* final MyCoolClass myObj = new MyCoolClass();
*
* TransferableObject.Fetcher fetcher = new TransferableObject.Fetcher()
* { public Object getObject() { return myObj; }
* }; // end fetcher
*
* Transferable xfer = new TransferableObject( fetcher );
* ...
* I'm releasing this code into the Public Domain. Enjoy.
* * @author Robert Harder * @author rob@iharder.net * @version 1.2 */ public static class TransferableObject implements Transferable { /** * The MIME type for {@link #DATA_FLAVOR} is * application/x-net.iharder.dnd.TransferableObject. */ public static final String MIME_TYPE = "application/x-net.iharder.dnd.TransferableObject"; /** * The default {@link java.awt.datatransfer.DataFlavor} for * {@link TransferableObject} has the representation class * net.iharder.dnd.TransferableObject.class * and the MIME type * application/x-net.iharder.dnd.TransferableObject. */ public static final DataFlavor DATA_FLAVOR = new DataFlavor(TransferableObject.class, MIME_TYPE); private Fetcher fetcher; private Object data; private DataFlavor customFlavor; /** * Creates a new {@link TransferableObject} that wraps data. * Along with the {@link #DATA_FLAVOR} associated with this class, * this creates a custom data flavor with a representation class * determined fromdata.getClass() and the MIME type
* application/x-net.iharder.dnd.TransferableObject.
*
* @param data The data to transfer
*/
public TransferableObject(Object data) {
this.data = data;
this.customFlavor = new DataFlavor(data.getClass(), MIME_TYPE);
}
/**
* Creates a new {@link TransferableObject} that will return the
* object that is returned by fetcher.
* No custom data flavor is set other than the default
* {@link #DATA_FLAVOR}.
*
* @param fetcher The {@link Fetcher} that will return the data object
* @see Fetcher
*/
public TransferableObject(Fetcher fetcher) {
this.fetcher = fetcher;
}
/**
* Creates a new {@link TransferableObject} that will return the
* object that is returned by fetcher.
* Along with the {@link #DATA_FLAVOR} associated with this class,
* this creates a custom data flavor with a representation class dataClass
* and the MIME type
* application/x-net.iharder.dnd.TransferableObject.
*
* @param dataClass The {@link java.lang.Class} to use in the custom data flavor
* @param fetcher The {@link Fetcher} that will return the data object
* @see Fetcher
*/
public TransferableObject(Class dataClass, Fetcher fetcher) {
this.fetcher = fetcher;
this.customFlavor = new DataFlavor(dataClass, MIME_TYPE);
}
/**
* Returns the custom {@link java.awt.datatransfer.DataFlavor} associated
* with the encapsulated object or null if the {@link Fetcher}
* constructor was used without passing a {@link java.lang.Class}.
*
* @return The custom data flavor for the encapsulated object
*/
public DataFlavor getCustomDataFlavor() {
return customFlavor;
}
/* ******** T R A N S F E R A B L E M E T H O D S ******** */
/**
* Returns a two- or three-element array containing first
* the custom data flavor, if one was created in the constructors,
* second the default {@link #DATA_FLAVOR} associated with
* {@link TransferableObject}, and third the
* {@link java.awt.datatransfer.DataFlavor#stringFlavor}.
*
* @return An array of supported data flavors
*/
@Override
public DataFlavor[] getTransferDataFlavors() {
if (customFlavor != null)
return new DataFlavor[] {
customFlavor,
DATA_FLAVOR,
DataFlavor.stringFlavor};
else
return new DataFlavor[] {
DATA_FLAVOR,
DataFlavor.stringFlavor};
}
/**
* Returns the data encapsulated in this {@link TransferableObject}.
* If the {@link Fetcher} constructor was used, then this is when
* the {@link Fetcher#getObject getObject()} method will be called.
* If the requested data flavor is not supported, then the
* {@link Fetcher#getObject getObject()} method will not be called.
*
* @param flavor The data flavor for the data to return
* @return The dropped data
*/
@Override
public Object getTransferData(DataFlavor flavor)
throws UnsupportedFlavorException, IOException {
// Native object
if (flavor.equals(DATA_FLAVOR))
return fetcher == null ? data : fetcher.getObject();
// String
if (flavor.equals(DataFlavor.stringFlavor))
return fetcher == null ? data.toString() : fetcher.getObject().toString();
// We can't do anything else
throw new UnsupportedFlavorException(flavor);
}
/**
* Returns true if flavor is one of the supported
* flavors. Flavors are supported using the equals(...) method.
*
* @param flavor The data flavor to check
* @return Whether or not the flavor is supported
*/
@Override
public boolean isDataFlavorSupported(DataFlavor flavor) {
// Native object
if (flavor.equals(DATA_FLAVOR))
return true;
// String
if (flavor.equals(DataFlavor.stringFlavor))
return true;
// We can't do anything else
return false;
}
/* ******** I N N E R I N T E R F A C E F E T C H E R ******** */
/**
* Instead of passing your data directly to the {@link TransferableObject}
* constructor, you may want to know exactly when your data was received
* in case you need to remove it from its source (or do anyting else to it).
* When the {@link #getTransferData getTransferData(...)} method is called
* on the {@link TransferableObject}, the {@link Fetcher}'s
* {@link #getObject getObject()} method will be called.
*
* @author Robert Harder
*/
public interface Fetcher {
/**
* Return the object being encapsulated in the
* {@link TransferableObject}.
*
* @return The dropped object
*/
Object getObject();
}
}
}