From a user's point of view dragging is done by clicking down a mouse button on some visual component (the "drag source") and moving the mouse until it is over a second component (the "drop target") at which point the button is released. The semantics of this are defined by the application, but it usually signals that the dragged object (in this case a table) has been moved or copied from the drag source to the drop target; it's an intuitive and user-friendly way to offer transfer of an object from one place (application window) to another. STIL's generic I/O classes provide methods to make drag and drop of tables very straightforward.
Dragging and dropping are handled separately but in either
case, you will need to construct a new
javax.swing.TransferHandler
object (subclassing TransferHandler itself and overriding
some methods as below) and install it on the Swing
JComponent which is to
do be the drag source/drop target using its
setTransferHandler method.
To allow a Swing component to accept tables that are dropped onto it,
implement TransferHandler's
canImport
and
importData
methods like this:
class TableDragTransferHandler extends TransferHandler {
StarTableFactory factory = new StarTableFactory();
public boolean canImport( JComponent comp, DataFlavor[] flavors ) {
return factory.canImport( flavors );
}
public boolean importData( JComponent comp, Transferable dropped ) {
try {
StarTable table = factory.makeStarTable( dropped );
processDroppedTable( table );
return true;
}
catch ( IOException e ) {
e.printStackTrace();
return false;
}
}
}
Then any time a table is dropped on that window, your
processDroppedTable method will be called on it.
To allow tables to be dragged off of a component, implement the
createTransferable
method like this:
class TableDropTransferHandler extends TransferHandler {
StarTableOutput writer = new StarTableOutput();
protected Transferable createTransferable( JComponent comp ) {
StarTable table = getMyTable();
return writer.transferStarTable( table );
}
}
(you may want to override
getSourceActions
and
getVisualRepresentation
as well.
For some Swing components
(see the
Swing Data Transfer documentation for a list),
this is all that is required.
For others, you will need to arrange to recognise the drag gesture
and trigger the TransferHandler's
exportAsDrag method as well;
you can use a DragListener
for this or see its source code for an example of how to do it.
Because of the way that Swing's Drag and Drop facilities work, this is not restricted to transferring tables between windows in the same application; if you incorporate one or other of these capabilities into your application, it will be able to exchange tables with any other application that does the same, even if it's running in a different Java Virtual Machine or on a different host - it just needs to have windows open on the same display device. TOPCAT is an example; you can drag tables off of or onto the Table List in the Control Window.