Drag sources initiate drags with the startDrag() method and create drag gesture recognizers with either createDragGestureRecognizer()or createDefaultDragGestureRecognizer() .

Drop targets are associated with a component and a drop target listener. When drop target events (including the drop) occur in the component, the listener is notified.

Transferables wrap data that is transferred from a drag source to a drop target.** The initiator of a drag wraps data in a transferable, and drops are handled by accessing a transferable's data.

Drag gesture listeners are notified of drag gestures by a recognizer. The typical response is to initiate a drag by invoking DragSource.startDrag().

Drag source listeners react to events that occur in a drag source after a drag is initiated.

Drop target listeners are responsible for handling drop target events including the actual drop itself.

On the surface, drag and drop can be intimidating. Drag sources, drop targets, drag gesture recognizers, and transferables must be created and a cast of listeners implemented for even the simplest drag and drop operation.

In practice, however, drag and drop is straightforward. Other than wrapping data in a transferable and handling the drop, most of the action takes place without programmer intervention.

Adding Drag and Drop to Swing Components

Adding drag and drop capabilities to Swing components typically involves one of the following options:

Both options involve associating components with drag sources and drop targets. The difference stems from who does the associating. For Option 1, it's a subclass of a Swing component. For Option 2, it's an object other than the component, the drag source, or the drop target.

Notice that extending a Swing component -- Option 1 -- adds drag and drop functionality only to instances of the component extension; functionality cannot be added to standard components. For example, drag and drop functionality in a ListThatsADragSource extension of JList is only available to instances of ListThatsADragSource and cannot be used with instances of JList . Therefore, the use of Option 1 should be limited to custom components with inherent drag and drop capabilities that are not easily generalized.

The application shown in Figure 1 exercises both options--the drag source is implemented as an extension of the JTree class, and an instance of JTextPane is associated with a drop target by the application. Filenames dragged from the tree and dropped in the textpane are displayed as text files. The top picture in Figure 1 shows the initiation of a drag, and the bottom picture shows the result of a subsequent drop in the text pane.

class DragTree extends JTree 
                implements DragGestureListener,
                DragSourceListener {    

   public DragTree() {

      DragSource dragSource = DragSource.getDefaultDragSource();


      // creating the recognizer is all that’s necessary - it
      // does not need to be manipulated after creation
      dragSource.createDefaultDragGestureRecognizer(
         this, // component where drag originates
         DnDConstants.ACTION_COPY_OR_MOVE, // actions
         this); // drag gesture listener
         ...
      }
      public void dragGestureRecognized(DragGestureEvent e) {
         // drag anything ...
         e.startDrag(DragSource.DefaultCopyDrop, // cursor
            new StringSelection(getFilename()), // transferable
            this); // drag source listener
      }
      public void dragDropEnd(DragSourceDropEvent e) {}
      public void dragEnter(DragSourceDragEvent e) {}
      public void dragExit(DragSourceEvent e) {}
      public void dragOver(DragSourceDragEvent e) {}
      public void dropActionChanged(DragSourceDragEvent e) {}
      ...
   }   

public class Test extends JFrame 
                 implements DropTargetListener {
   private JTextPane textPane = new JTextPane();
   public Test() {
      ...
      new DropTarget(textPane, // component
        DnDConstants.ACTION_COPY_OR_MOVE, // actions
         this); // DropTargetListener
      ...
   }
   ...
   public void drop(DropTargetDropEvent e) {
      try {
         DataFlavor stringFlavor = DataFlavor.stringFlavor;
         Transferable tr = e.getTransferable();
         if(e.isDataFlavorSupported(stringFlavor)) {
            String filename = 
                 (String)tr.getTransferData(stringFlavor);
            e.acceptDrop(DnDConstants.ACTION_COPY_OR_MOVE);
            readFile(filename);
            textPane.setCaretPosition(0);
            e.dropComplete(true);
         }
         else {
            e.rejectDrop();
         }
      }
      catch(IOException ioe) {
         ioe.printStackTrace();
      }
      catch(UnsupportedFlavorException ufe) {
         ufe.printStackTrace();
      }
    }
    public void dragEnter(DropTargetDragEvent e) { }
    public void dragExit(DropTargetEvent e) { }
    public void dragOver(DropTargetDragEvent e) { }
    public void dropActionChanged(DropTargetDragEvent e) { }
}          

class DragTree extends JTree implements DragGestureListener,
        DragSourceListener {
   ...
   public void dragGestureRecognized(DragGestureEvent e) {
     String s = getFilename();
     if(s.endsWith(".txt") || s.endsWith(".java")) {
        e.startDrag(DragSource.DefaultCopyDrop,   // cursor
           new StringSelection(s),     // transferable
           this);  // drag source listener
     }
     else {
        SwingUtilities.invokeLater(new Runnable() {
           public void run() {
              JOptionPane.showMessageDialog(
                 SwingUtilities.getRootPane(DragTree.this),
                 "Only \".txt\" and \".java\" 
                 files " +
                 "can be dragged",
                 "Not Draggable",
                 JOptionPane.ERROR_MESSAGE);
           }
        });
     }
   }
   ...
 }         

A Drag and Drop Recipe

Using drag and drop is relatively simple, as illustrated by the example discussed in "Adding Drag and Drop to Swing Components." Perhaps the most difficult aspect of drag and drop is remembering all of the steps involved; because of this difficulty, we will conclude with a recipe for drag and drop:

1. Obtain a reference to a drag source with DragSource.getDefaultDragSource() or by instantiating a new one -- for example, new DragSource() .
2. Create a drag gesture recognizer with the drag source from step 1 by invoking DragSource.createDefaultDragGestureRecognizer(). The method is passed the component where the drag originates.
3. Create a drop target, specifying a component and a drop target listener.
4. Wrap the data to be dragged in a transferable.
5. Initiate a drag when the drag gesture recognizer from step 2 is notified by invoking DragSource.startDrag() for the drag source from step 1. The transferable from step 4 is passed to the startDrag() method.
6. Handle the drop by implementing the DropTargetListener interface.
7. Implement the DragSource interface (often with empty methods).