原文： http://zetcode.com/tutorials/javaswingtutorial/draganddrop/

在计算机图形用户界面中，拖放是单击虚拟对象并将其拖动到其他位置或另一个虚拟对象上的动作（或支持以下动作）。 通常，它可用于调用多种动作，或在两个抽象对象之间创建各种类型的关联。

Tweet

拖放

拖放操作使用户可以直观地完成复杂的事情。

通常，我们可以拖放两件事：数据或某些图形对象。 如果将图像从一个应用拖到另一个应用，则会拖放二进制数据。 如果我们在 Firefox 中拖动选项卡并将其移动到另一个位置，则将拖放图形组件。

Swing 中的拖放 - 图1

图：Swing 中的拖放

开始拖动操作的组件必须注册一个DragSource对象。 DropTarget是负责在拖放操作中接受拖放的对象。 Transferable封装正在传输的数据。 传输的数据可以是各种类型。 DataFlavor对象提供有关正在传输的数据的信息。

几个 Swing 组件已经内置了对拖放操作的支持。 在这种情况下，我们使用TransferHandler来管理拖放功能。 在没有内置支持的情况下，我们必须从头开始创建所有内容。

Swing 文本拖放示例

我们将演示一个简单的拖放示例。 我们将使用内置的拖放支持。 我们利用了TransferHandler类。

SimpeDnD.java

  1. package com.zetcode;
  3. import javax.swing.GroupLayout;
  4. import javax.swing.JButton;
  5. import javax.swing.JComponent;
  6. import javax.swing.JFrame;
  7. import javax.swing.JTextField;
  8. import javax.swing.TransferHandler;
  9. import java.awt.EventQueue;
  11. public class SimpleDnD extends JFrame {
  13.     private JTextField field;
  14.     private JButton button;
  16.     public SimpleDnD() {
  18.         initUI();
  19.     }
  21.     private void initUI() {
  23.         setTitle("Simple Drag & Drop");
  25.         button = new JButton("Button");
  26.         field = new JTextField(15);
  28.         field.setDragEnabled(true);
  29.         button.setTransferHandler(new TransferHandler("text"));
  31.         createLayout(field, button);
  33.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  34.         setLocationRelativeTo(null);
  35.     }
  37.     private void createLayout(JComponent... arg) {
  39.         var pane = getContentPane();
  40.         var gl = new GroupLayout(pane);
  41.         pane.setLayout(gl);
  43.         gl.setAutoCreateContainerGaps(true);
  44.         gl.setAutoCreateGaps(true);
  46.         gl.setHorizontalGroup(gl.createSequentialGroup()
  47.                 .addComponent(arg[0])
  48.                 .addComponent(arg[1])
  49.         );
  51.         gl.setVerticalGroup(gl.createParallelGroup(GroupLayout.Alignment.BASELINE)
  52.                 .addComponent(arg[0])
  53.                 .addComponent(arg[1])
  54.         );
  56.         pack();
  57.     }
  59.     public static void main(String[] args) {
  61.         EventQueue.invokeLater(() -> {
  63.             var ex = new SimpleDnD();
  64.             ex.setVisible(true);
  65.         });
  66.     }
  67. }

在我们的示例中，我们有一个文本字段和一个按钮。 我们可以将文本从字段中拖放到按钮上。

  1. field.setDragEnabled(true);

文本字段具有内置的拖动支持。 我们必须启用它。

  1. button.setTransferHandler(new TransferHandler("text"));

TransferHandler是负责在组件之间传输数据的类。 构造器将属性名称作为参数。

Swing 图标拖放

一些 Java Swing 组件没有内置的拖动支持。 JLabel组件就是这样的组件。 我们必须自己编写拖动功能。

以下示例显示了如何拖放图标。 在前面的示例中，我们使用了text属性。 这次我们使用icon属性。

IconDnD.java

  1. package com.zetcode;
  3. import javax.swing.GroupLayout;
  4. import javax.swing.ImageIcon;
  5. import javax.swing.JButton;
  6. import javax.swing.JComponent;
  7. import javax.swing.JFrame;
  8. import javax.swing.JLabel;
  9. import javax.swing.TransferHandler;
  10. import java.awt.EventQueue;
  11. import java.awt.event.MouseAdapter;
  12. import java.awt.event.MouseEvent;
  14. public class IconDnD extends JFrame {
  16.     public IconDnD() {
  18.         initUI();
  19.     }
  21.     private void initUI() {
  23.         var icon1 = new ImageIcon("src/resources/sad.png");
  24.         var icon2 = new ImageIcon("src/resources/plain.png");
  25.         var icon3 = new ImageIcon("src/resources/smile.png");
  27.         var label1 = new JLabel(icon1, JLabel.CENTER);
  28.         var label2 = new JLabel(icon2, JLabel.CENTER);
  29.         var label3 = new JLabel(icon3, JLabel.CENTER);
  31.         var listener = new DragMouseAdapter();
  32.         label1.addMouseListener(listener);
  33.         label2.addMouseListener(listener);
  34.         label3.addMouseListener(listener);
  36.         var button = new JButton(icon2);
  37.         button.setFocusable(false);
  39.         label1.setTransferHandler(new TransferHandler("icon"));
  40.         label2.setTransferHandler(new TransferHandler("icon"));
  41.         label3.setTransferHandler(new TransferHandler("icon"));
  42.         button.setTransferHandler(new TransferHandler("icon"));
  44.         createLayout(label1, label2, label3, button);
  46.         setTitle("Icon Drag & Drop");
  47.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  48.         setLocationRelativeTo(null);
  49.     }
  51.     private class DragMouseAdapter extends MouseAdapter {
  53.         public void mousePressed(MouseEvent e) {
  55.             var c = (JComponent) e.getSource();
  56.             var handler = c.getTransferHandler();
  57.             handler.exportAsDrag(c, e, TransferHandler.COPY);
  58.         }
  59.     }
  61.     private void createLayout(JComponent... arg) {
  63.         var pane = getContentPane();
  64.         var gl = new GroupLayout(pane);
  65.         pane.setLayout(gl);
  67.         gl.setAutoCreateContainerGaps(true);
  68.         gl.setAutoCreateGaps(true);
  70.         gl.setHorizontalGroup(gl.createParallelGroup(GroupLayout.Alignment.CENTER)
  71.                 .addGroup(gl.createSequentialGroup()
  72.                         .addComponent(arg[0])
  73.                         .addGap(30)
  74.                         .addComponent(arg[1])
  75.                         .addGap(30)
  76.                         .addComponent(arg[2])
  77.                 )
  78.                 .addComponent(arg[3], GroupLayout.DEFAULT_SIZE,
  79.                         GroupLayout.DEFAULT_SIZE, Integer.MAX_VALUE)
  80.         );
  82.         gl.setVerticalGroup(gl.createSequentialGroup()
  83.                 .addGroup(gl.createParallelGroup()
  84.                         .addComponent(arg[0])
  85.                         .addComponent(arg[1])
  86.                         .addComponent(arg[2]))
  87.                 .addGap(30)
  88.                 .addComponent(arg[3])
  89.         );
  91.         pack();
  92.     }
  94.     public static void main(String[] args) {
  96.         EventQueue.invokeLater(() -> {
  98.             var ex = new IconDnD();
  99.             ex.setVisible(true);
  100.         });
  101.     }
  102. }

在代码示例中，我们有两个标签和一个按钮。 每个组件都显示一个图标。 这两个标签启用拖动手势，按钮接受放置手势。

  1. label1.setTransferHandler(new TransferHandler("icon"));
  2. label2.setTransferHandler(new TransferHandler("icon"));
  3. label3.setTransferHandler(new TransferHandler("icon"));

默认情况下，标签的拖动支持未启用。 我们为这两个标签注册了一个自定义鼠标适配器。

  1. label1.setTransferHandler(new TransferHandler("icon"));
  2. label2.setTransferHandler(new TransferHandler("icon"));
  3. label3.setTransferHandler(new TransferHandler("icon"));
  4. button.setTransferHandler(new TransferHandler("icon"));

每个组件都有一个用于图标属性的TransferHandler类。 拖动源和拖动目标也需要TransferHandler。

  1. var c = (JComponent) e.getSource();
  2. var handler = c.getTransferHandler();
  3. handler.exportAsDrag(c, e, TransferHandler.COPY);

这些代码行启动拖动支持。 我们得到了拖动源。 在我们的例子中，它是一个标签实例。 我们获取其传输处理器对象，并最终通过exportAsDrag()方法调用来启动拖动支持。

Swing 中的拖放 - 图2

图：图标 drag & drop example

Swing JList放置示例

某些组件没有默认的放置支持。 其中之一是JList。 这是有充分的理由的。 我们不知道是将数据插入一行，还是插入两行或更多行。 因此，我们必须手动实现对列表组件的拖放支持。

下面的示例将逗号或空格分隔的文本插入JList组件的行中。 否则，文本将进入一行。

ListDnD.java

  1. package com.zetcode;
  3. import javax.swing.DefaultListModel;
  4. import javax.swing.DropMode;
  5. import javax.swing.GroupLayout;
  6. import javax.swing.JComponent;
  7. import javax.swing.JFrame;
  8. import javax.swing.JList;
  9. import javax.swing.JScrollPane;
  10. import javax.swing.JTextField;
  11. import javax.swing.ListSelectionModel;
  12. import javax.swing.TransferHandler;
  13. import java.awt.Dimension;
  14. import java.awt.EventQueue;
  15. import java.awt.datatransfer.DataFlavor;
  17. public class ListDnD extends JFrame {
  19.     private JTextField field;
  20.     private DefaultListModel model;
  22.     public ListDnD() {
  24.         initUI();
  25.     }
  27.     private void initUI() {
  29.         var scrollPane = new JScrollPane();
  30.         scrollPane.setPreferredSize(new Dimension(180, 150));
  32.         model = new DefaultListModel();
  33.         var myList = new JList(model);
  35.         myList.setDropMode(DropMode.INSERT);
  36.         myList.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  37.         myList.setTransferHandler(new ListHandler());
  39.         field = new JTextField(15);
  40.         field.setDragEnabled(true);
  42.         scrollPane.getViewport().add(myList);
  44.         createLayout(field, scrollPane);
  46.         setTitle("ListDrop");
  47.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  48.         setLocationRelativeTo(null);
  49.     }
  51.     private class ListHandler extends TransferHandler {
  53.         public boolean canImport(TransferSupport support) {
  55.             if (!support.isDrop()) {
  56.                 return false;
  57.             }
  59.             return support.isDataFlavorSupported(DataFlavor.stringFlavor);
  60.         }
  62.         public boolean importData(TransferSupport support) {
  64.             if (!canImport(support)) {
  65.                 return false;
  66.             }
  68.             var transferable = support.getTransferable();
  69.             String line;
  71.             try {
  72.                 line = (String) transferable.getTransferData(DataFlavor.stringFlavor);
  73.             } catch (Exception e) {
  74.                 return false;
  75.             }
  77.             var dl = (JList.DropLocation) support.getDropLocation();
  78.             int index = dl.getIndex();
  80.             String[] data = line.split("[,\\s]");
  82.             for (String item : data) {
  84.                 if (!item.isEmpty())
  85.                     model.add(index++, item.trim());
  86.             }
  88.             return true;
  89.         }
  90.     }
  92.     private void createLayout(JComponent... arg) {
  94.         var pane = getContentPane();
  95.         var gl = new GroupLayout(pane);
  96.         pane.setLayout(gl);
  98.         gl.setAutoCreateContainerGaps(true);
  99.         gl.setAutoCreateGaps(true);
  101.         gl.setHorizontalGroup(gl.createSequentialGroup()
  102.                 .addComponent(arg[0])
  103.                 .addComponent(arg[1])
  104.         );
  106.         gl.setVerticalGroup(gl.createParallelGroup(GroupLayout.Alignment.BASELINE)
  107.                 .addComponent(arg[0])
  108.                 .addComponent(arg[1])
  109.         );
  111.         pack();
  112.     }
  114.     public static void main(String[] args) {
  115.         EventQueue.invokeLater(() -> {
  117.             var ex = new ListDnD();
  118.             ex.setVisible(true);
  119.         });
  120.     }
  121. }

在示例中，我们有一个文本字段和一个列表组件。 可以将文本字段中的文本拖放到列表中。 如果文本用逗号或空格字符逗号分隔，则单词将分成几行。 如果不是，则将文本插入一行。

  1. myList.setDropMode(DropMode.INSERT);

在这里，我们指定放置模式。 DropMode.INSERT指定我们将要在列表组件中插入新项目。 如果选择DropMode.INSERT，则将新项目拖放到现有项目上。

  1. myList.setTransferHandler(new ListHandler());

我们设置了一个自定义的传输处理器类。

  1. field.setDragEnabled(true);

我们为文本字段组件启用了拖动支持。

  1. public boolean canImport(TransferSupport support) {
  3.     if (!support.isDrop()) {
  4.         return false;
  5.     }
  7.     return support.isDataFlavorSupported(DataFlavor.stringFlavor);
  8. }

此方法测试放置操作的适用性。 我们过滤掉剪贴板粘贴操作，仅允许字符串放置操作。 如果该方法返回 false，则取消放置操作。

  1. public boolean importData(TransferSupport support) {
  2. ...
  3. }

importData()方法将数据从剪贴板或拖放操作传输到放置位置。

  1. var transferable = support.getTransferable();

Transferable是数据捆绑在一起的类。

  1. line = (String) transferable.getTransferData(DataFlavor.stringFlavor);

我们检索我们的数据。

  1. var dl = (JList.DropLocation) support.getDropLocation();
  2. int index = dl.getIndex();

我们得到该列表的放置位置。 我们检索将在其中插入数据的索引。

  1. String[] data = line.split("[,\\s]");
  3. for (String item : data) {
  5.     if (!item.isEmpty())
  6.         model.add(index++, item.trim());
  7. }

我们将文本分为几部分，然后将其插入一行或多行中。

Swing 中的拖放 - 图3

图：JList放置示例

前面的示例使用了具有内置拖放支持的组件。 接下来，我们将从头开始创建拖放功能。

Swing 拖动手势

在以下示例中，我们检查了一个简单的拖动手势。 我们处理创建拖动手势所需的几个类。 DragSource，DragGestureEvent，DragGestureListener和Transferable。

DragGesture.java

  1. package com.zetcode;
  3. import javax.swing.GroupLayout;
  4. import javax.swing.JComponent;
  5. import javax.swing.JFrame;
  6. import javax.swing.JPanel;
  7. import java.awt.Color;
  8. import java.awt.Cursor;
  9. import java.awt.Dimension;
  10. import java.awt.EventQueue;
  11. import java.awt.datatransfer.DataFlavor;
  12. import java.awt.datatransfer.Transferable;
  13. import java.awt.dnd.DnDConstants;
  14. import java.awt.dnd.DragGestureEvent;
  15. import java.awt.dnd.DragGestureListener;
  16. import java.awt.dnd.DragSource;
  18. public class DragGesture extends JFrame implements
  19.         DragGestureListener, Transferable {
  21.     public DragGesture() {
  23.         initUI();
  24.     }
  26.     private void initUI() {
  28.         var redPanel = new JPanel();
  29.         redPanel.setBackground(Color.red);
  30.         redPanel.setPreferredSize(new Dimension(120, 120));
  32.         var ds = new DragSource();
  34.         ds.createDefaultDragGestureRecognizer(redPanel,
  35.                 DnDConstants.ACTION_COPY, this);
  37.         createLayout(redPanel);
  39.         setTitle("Drag Gesture");
  40.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  41.         setLocationRelativeTo(null);
  42.     }
  44.     public void dragGestureRecognized(DragGestureEvent event) {
  46.         var cursor = Cursor.getDefaultCursor();
  48.         if (event.getDragAction() == DnDConstants.ACTION_COPY) {
  50.             cursor = DragSource.DefaultCopyDrop;
  51.         }
  53.         event.startDrag(cursor, this);
  54.     }
  56.     public Object getTransferData(DataFlavor flavor) {
  58.         return null;
  59.     }
  61.     public DataFlavor[] getTransferDataFlavors() {
  63.         return new DataFlavor[0];
  64.     }
  66.     public boolean isDataFlavorSupported(DataFlavor flavor) {
  68.         return false;
  69.     }
  71.     private void createLayout(JComponent... arg) {
  73.         var pane = getContentPane();
  74.         var gl = new GroupLayout(pane);
  75.         pane.setLayout(gl);
  77.         gl.setAutoCreateContainerGaps(true);
  78.         gl.setAutoCreateGaps(true);
  80.         gl.setHorizontalGroup(gl.createSequentialGroup()
  81.                 .addGap(50)
  82.                 .addComponent(arg[0])
  83.                 .addGap(50)
  84.         );
  86.         gl.setVerticalGroup(gl.createSequentialGroup()
  87.                 .addGap(50)
  88.                 .addComponent(arg[0])
  89.                 .addGap(50)
  90.         );
  92.         pack();
  93.     }
  95.     public static void main(String[] args) {
  97.         EventQueue.invokeLater(() -> {
  99.             var ex = new DragGesture();
  100.             ex.setVisible(true);
  101.         });
  102.     }
  103. }

这个简单的示例演示了拖动手势。 当我们单击组件并在按下按钮时移动鼠标指针时，将创建拖动手势。 该示例说明了如何为组件创建DragSource。

  1. public class DragGesture extends JFrame implements 
  2.    DragGestureListener, Transferable {

DragGesture实现两个接口。 DragGestureListener监听拖动手势。 Transferable处理用于传输操作的数据。 在该示例中，我们将不会传输任何数据； 我们仅演示拖动手势。 Transferable接口的三种必要方法未实现。

  1. var ds = new DragSource();
  3. ds.createDefaultDragGestureRecognizer(redPanel,
  4.         DnDConstants.ACTION_COPY, this);

在这里，我们创建一个DragSource对象并将其注册到面板。 DragSource是负责启动拖放操作的实体。 createDefaultDragGestureRecognizer()将拖动源和DragGestureListener与特定组件相关联。

  1. public void dragGestureRecognized(DragGestureEvent event) {
  3. }

dragGestureRecognized()方法响应拖动手势。

  1. var cursor = Cursor.getDefaultCursor();
  3. if (event.getDragAction() == DnDConstants.ACTION_COPY) {
  4.     cursor = DragSource.DefaultCopyDrop;
  5. }
  7. event.startDrag(cursor, this);

DragGestureEvent的startDrag()方法最终开始拖动操作。 我们指定两个参数：游标类型和Transferable对象。

  1. public Object getTransferData(DataFlavor flavor) {
  3.     return null;
  4. }
  6. public DataFlavor[] getTransferDataFlavors() {
  8.     return new DataFlavor[0];
  9. }
  11. public boolean isDataFlavorSupported(DataFlavor flavor) {
  13.     return false;
  14. }

实现Transferable接口的对象必须实现这三种方法。 还没有功能。

一个复杂的拖放示例

在下面的示例中，我们创建一个复杂的拖放示例。 我们创建拖动源，放置目标和可移动对象。

ComplexDnD.java

  1. package com.zetcode;
  3. import javax.swing.GroupLayout;
  4. import javax.swing.JButton;
  5. import javax.swing.JColorChooser;
  6. import javax.swing.JComponent;
  7. import javax.swing.JFrame;
  8. import javax.swing.JPanel;
  9. import java.awt.Color;
  10. import java.awt.Cursor;
  11. import java.awt.Dimension;
  12. import java.awt.EventQueue;
  13. import java.awt.datatransfer.DataFlavor;
  14. import java.awt.datatransfer.Transferable;
  15. import java.awt.datatransfer.UnsupportedFlavorException;
  16. import java.awt.dnd.DnDConstants;
  17. import java.awt.dnd.DragGestureEvent;
  18. import java.awt.dnd.DragGestureListener;
  19. import java.awt.dnd.DragSource;
  20. import java.awt.dnd.DropTarget;
  21. import java.awt.dnd.DropTargetAdapter;
  22. import java.awt.dnd.DropTargetDropEvent;
  24. public class ComplexDnD extends JFrame
  25.         implements DragGestureListener {
  27.     private JPanel leftPanel;
  29.     public ComplexDnD() {
  31.         initUI();
  32.     }
  34.     private void initUI() {
  36.         var colourBtn = new JButton("Choose Color");
  37.         colourBtn.setFocusable(false);
  39.         leftPanel = new JPanel();
  40.         leftPanel.setBackground(Color.red);
  41.         leftPanel.setPreferredSize(new Dimension(100, 100));
  43.         colourBtn.addActionListener(event -> {
  45.             var color = JColorChooser.showDialog(this, "Choose Color", Color.white);
  46.             leftPanel.setBackground(color);
  47.         });
  49.         var rightPanel = new JPanel();
  50.         rightPanel.setBackground(Color.white);
  51.         rightPanel.setPreferredSize(new Dimension(100, 100));
  53.         var mtl = new MyDropTargetListener(rightPanel);
  55.         var ds = new DragSource();
  56.         ds.createDefaultDragGestureRecognizer(leftPanel,
  57.                 DnDConstants.ACTION_COPY, this);
  59.         createLayout(colourBtn, leftPanel, rightPanel);
  61.         setTitle("Complex drag and drop example");
  62.         setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  63.         setLocationRelativeTo(null);
  64.     }
  66.     public void dragGestureRecognized(DragGestureEvent event) {
  68.         var cursor = Cursor.getDefaultCursor();
  69.         var panel = (JPanel) event.getComponent();
  71.         var color = panel.getBackground();
  73.         if (event.getDragAction() == DnDConstants.ACTION_COPY) {
  74.             cursor = DragSource.DefaultCopyDrop;
  75.         }
  77.         event.startDrag(cursor, new TransferableColor(color));
  78.     }
  80.     private class MyDropTargetListener extends DropTargetAdapter {
  82.         private final DropTarget dropTarget;
  83.         private final JPanel panel;
  85.         public MyDropTargetListener(JPanel panel) {
  86.             this.panel = panel;
  88.             dropTarget = new DropTarget(panel, DnDConstants.ACTION_COPY,
  89.                     this, true, null);
  90.         }
  92.         public void drop(DropTargetDropEvent event) {
  94.             try {
  96.                 var tr = event.getTransferable();
  97.                 var col = (Color) tr.getTransferData(TransferableColor.colorFlavor);
  99.                 if (event.isDataFlavorSupported(TransferableColor.colorFlavor)) {
  101.                     event.acceptDrop(DnDConstants.ACTION_COPY);
  102.                     this.panel.setBackground(col);
  103.                     event.dropComplete(true);
  104.                     return;
  105.                 }
  107.                 event.rejectDrop();
  108.             } catch (Exception e) {
  110.                 e.printStackTrace();
  111.                 event.rejectDrop();
  112.             }
  113.         }
  114.     }
  116.     private void createLayout(JComponent... arg) {
  118.         var pane = getContentPane();
  119.         var gl = new GroupLayout(pane);
  120.         pane.setLayout(gl);
  122.         gl.setAutoCreateContainerGaps(true);
  123.         gl.setAutoCreateGaps(true);
  125.         gl.setHorizontalGroup(gl.createSequentialGroup()
  126.                 .addComponent(arg[0])
  127.                 .addGap(30)
  128.                 .addComponent(arg[1])
  129.                 .addGap(30)
  130.                 .addComponent(arg[2])
  131.         );
  133.         gl.setVerticalGroup(gl.createParallelGroup()
  134.                 .addComponent(arg[0])
  135.                 .addComponent(arg[1])
  136.                 .addComponent(arg[2])
  137.         );
  139.         pack();
  140.     }
  142.     public static void main(String[] args) {
  144.         EventQueue.invokeLater(() -> {
  146.             var ex = new ComplexDnD();
  147.             ex.setVisible(true);
  148.         });
  149.     }
  150. }
  152. class TransferableColor implements Transferable {
  154.     protected static final DataFlavor colorFlavor =
  155.             new DataFlavor(Color.class, "A Color Object");
  157.     protected static final DataFlavor[] supportedFlavors = {
  158.             colorFlavor,
  159.             DataFlavor.stringFlavor,
  160.     };
  162.     private final Color color;
  164.     public TransferableColor(Color color) {
  166.         this.color = color;
  167.     }
  169.     public DataFlavor[] getTransferDataFlavors() {
  171.         return supportedFlavors;
  172.     }
  174.     public boolean isDataFlavorSupported(DataFlavor flavor) {
  176.         return flavor.equals(colorFlavor) ||
  177.                 flavor.equals(DataFlavor.stringFlavor);
  178.     }
  180.     public Object getTransferData(DataFlavor flavor)
  181.             throws UnsupportedFlavorException {
  183.         if (flavor.equals(colorFlavor)) {
  184.             return color;
  185.         } else if (flavor.equals(DataFlavor.stringFlavor)) {
  186.             return color.toString();
  187.         } else {
  188.             throw new UnsupportedFlavorException(flavor);
  189.         }
  190.     }
  191. }

该代码示例显示一个按钮和两个面板。 该按钮显示一个颜色选择器对话框，并为第一个面板设置颜色。 可以将颜色拖到第二个面板中。

此示例增强了前一个示例。 我们将添加放置目标和自定义可转移对象。

  1. var mtl = new MyDropTargetListener(rightPanel);

我们在右侧面板中注册放置目标监听器。

  1. event.startDrag(cursor, new TransferableColor(color));

startDrag()方法具有两个参数。 游标和Transferable对象。

  1. public MyDropTargetListener(JPanel panel) {
  2.     this.panel = panel;
  4.     dropTarget = new DropTarget(panel, DnDConstants.ACTION_COPY, 
  5.         this, true, null);
  6. }

在MyDropTargetListener中，我们创建一个放置目标对象。

  1. var tr = event.getTransferable();
  2. var col = (Color) tr.getTransferData(TransferableColor.colorFlavor);
  4. if (event.isDataFlavorSupported(TransferableColor.colorFlavor)) {
  6.     event.acceptDrop(DnDConstants.ACTION_COPY);
  7.     this.panel.setBackground(color);
  8.     event.dropComplete(true);
  9.     return;
  10. }

我们得到正在传输的数据。 在我们的情况下，它是一个颜色对象。 在这里，我们设置右侧面板的颜色。

  1. event.rejectDrop();

如果不满足拖放操作的条件，我们将拒绝它。

  1. protected static DataFlavor colorFlavor =
  2.     new DataFlavor(Color.class, "A Color Object");

在TransferableColor中，我们创建一个新的DataFlavor对象。

  1. protected static DataFlavor[] supportedFlavors = {
  2.     colorFlavor,
  3.     DataFlavor.stringFlavor,
  4. };

在这里，我们指定了我们支持的数据类型。 在我们的情况下，这是一个自定义的颜色味道和预定义的DataFlavor.stringFlavor。

  1. public Object getTransferData(DataFlavor flavor)
  2.         throws UnsupportedFlavorException {
  4.     if (flavor.equals(colorFlavor)) {
  5.         return color;
  6.     } else if (flavor.equals(DataFlavor.stringFlavor)) {
  7.         return color.toString();
  8.     } else {
  9.         throw new UnsupportedFlavorException(flavor);
  10.     }
  11. }

getTransferData()返回一个具有特定数据风味的对象。

Java Swing 教程的这一部分专门用于 Swing 的拖放操作。