顶级掉落

原文： https://docs.oracle.com/javase/tutorial/uiswing/dnd/toplevel.html

到目前为止，我们主要专注于将TransferHandler附加到JComponent子类之一。但您也可以直接在顶级容器上设置TransferHandler，例如JFrame和JDialog。

这对于导入文件的应用程序特别有用，例如编辑器，IDE，图像处理器，CD 刻录程序。这种应用程序通常包括菜单，工具栏，用于编辑文档的区域，以及可能用于在打开的文档之间切换的列表或机制。

我们有这样的例子但是因为这个演示读取文件，我们不提供 Java Web Start 版本 - 你必须自己下载并编译演示。

正如您在下面的屏幕截图中看到的，TopLevelTransferHandlerDemo有一个菜单（空的，Demo 子菜单除外），一个（非功能性）工具栏，一个显示打开文档列表的区域（左侧），以及显示每个打开文档内容的区域（右侧）。启动时，蓝色文档区域已分配了一个支持文件导入的传输处理器 - 因此是唯一可以接受删除的地方。

A snapshot of the TopLevelTransferHandlerDemo demo.

Try this:

  1. 编译并运行 TopLevelTransferHandlerDemo示例，如果要下载为 NetBeans 构建的 zip 文件，请查阅示例索引。
  2. 从原生桌面或文件系统中拖出文件，然后将其放在右侧的蓝色文档区域中。该文件将打开，并显示一个填充其内容的框架。文档区域JDesktopPane包含支持导入javaFileListFlavor的传输处理器。
  3. 拖动另一个文件并尝试将其放在文档区域上。您会发现无法将其放在显示最后一个文件的框架顶部。您也不能将其放在列表，菜单或工具栏上。您可以删除的唯一位置是文档区域的蓝色部分或以前打开的框架的菜单栏上。在每个内容框架内部都有一个文本组件的传输处理器，它不理解文件丢弃 - 您可以将文本拖放到该区域，但不能删除文件。
  4. 从菜单中选择 Demo->使用 Top-Level TransferHandler 在顶级容器上安装传输处理器 - JFrame。
  5. 尝试再次拖动演示。接受跌落的区域数量增加了。您现在可以删除应用程序上的大多数位置，包括菜单栏，工具栏，框架的标题栏，列表（左侧）或以前打开的文件的内容区域除外。 JList和文本区域的传输处理器都不知道如何导入文件。
  6. 通过从菜单中选择 Demo->从列表和文本中删除 TransferHandler，禁用这些剩余组件上的传输处理器。
  7. 再次拖动演示。您现在可以在应用程序的任何位置删除文件*！_
  8. 从菜单中选择 Demo-> Use COPY Action。
  9. 再次拖动演示。请注意，鼠标光标现在显示 COPY 光标 - 这提供了更准确的反馈，因为成功的删除不会从源中删除文件。目标可以编程为从选择放下动作中描述的可用放下动作中进行选择。

请注意禁用文本组件上的默认传输处理器的一个不良副作用：您无法再在编辑区域内拖放（或剪切/复制/粘贴）文本。要解决此问题，您需要为接受文件丢弃的文本组件实现自定义传输处理器，并重新实现缺少的文本传输支持。您可能想要观看 RFE 4830695 ，这将允许在现有TransferHandler之上添加数据导入。

这是 TopLevelTransferHandlerDemo.java 的源代码：

  1. /**
  2.  * Demonstration of the top-level {@code TransferHandler}
  3.  * support on {@code JFrame}.
  4.  */
  5. public class TopLevelTransferHandlerDemo extends JFrame {
  7.     private static boolean DEMO = false;
  9.     private JDesktopPane dp = new JDesktopPane();
  10.     private DefaultListModel listModel = new DefaultListModel();
  11.     private JList list = new JList(listModel);
  12.     private static int left;
  13.     private static int top;
  14.     private JCheckBoxMenuItem copyItem;
  15.     private JCheckBoxMenuItem nullItem;
  16.     private JCheckBoxMenuItem thItem;
  18.     private class Doc extends InternalFrameAdapter implements ActionListener {
  19.         String name;
  20.         JInternalFrame frame;
  21.         TransferHandler th;
  22.         JTextArea area;
  24.         public Doc(File file) {
  25.             this.name = file.getName();
  26.             try {
  27.                 init(file.toURI().toURL());
  28.             } catch (MalformedURLException e) {
  29.                 e.printStackTrace();
  30.             }
  31.         }
  33.         public Doc(String name) {
  34.             this.name = name;
  35.             init(getClass().getResource(name));
  36.         }
  38.         private void init(URL url) {
  39.             frame = new JInternalFrame(name);
  40.             frame.addInternalFrameListener(this);
  41.             listModel.add(listModel.size(), this);
  43.             area = new JTextArea();
  44.             area.setMargin(new Insets(5, 5, 5, 5));
  46.             try {
  47.                 BufferedReader reader = new BufferedReader(new InputStreamReader(url.openStream()));
  48.                 String in;
  49.                 while ((in = reader.readLine()) != null) {
  50.                     area.append(in);
  51.                     area.append("\n");
  52.                 }
  53.                 reader.close();
  54.             } catch (Exception e) {
  55.                 e.printStackTrace();
  56.                 return;
  57.             }
  59.             th = area.getTransferHandler();
  60.             area.setFont(new Font("monospaced", Font.PLAIN, 12));
  61.             area.setCaretPosition(0);
  62.             area.setDragEnabled(true);
  63.             area.setDropMode(DropMode.INSERT);
  64.             frame.getContentPane().add(new JScrollPane(area));
  65.             dp.add(frame);
  66.             frame.show();
  67.             if (DEMO) {
  68.                 frame.setSize(300, 200);
  69.             } else {
  70.                 frame.setSize(400, 300);
  71.             }
  72.             frame.setResizable(true);
  73.             frame.setClosable(true);
  74.             frame.setIconifiable(true);
  75.             frame.setMaximizable(true);
  76.             frame.setLocation(left, top);
  77.             incr();
  78.             SwingUtilities.invokeLater(new Runnable() {
  79.                 public void run() {
  80.                     select();
  81.                 }
  82.             });
  83.             nullItem.addActionListener(this);
  84.             setNullTH();
  85.         }
  87.         public void internalFrameClosing(InternalFrameEvent event) {
  88.             listModel.removeElement(this);
  89.             nullItem.removeActionListener(this);
  90.         }
  92.         public void internalFrameOpened(InternalFrameEvent event) {
  93.             int index = listModel.indexOf(this);
  94.             list.getSelectionModel().setSelectionInterval(index, index);
  95.         }
  97.         public void internalFrameActivated(InternalFrameEvent event) {
  98.             int index = listModel.indexOf(this);
  99.             list.getSelectionModel().setSelectionInterval(index, index);
  100.         }
  102.         public String toString() {
  103.             return name;
  104.         }
  106.         public void select() {
  107.             try {
  108.                 frame.toFront();
  109.                 frame.setSelected(true);
  110.             } catch (java.beans.PropertyVetoException e) {}
  111.         }
  113.         public void actionPerformed(ActionEvent ae) {
  114.             setNullTH();
  115.         }
  117.         public void setNullTH() {
  118.             if (nullItem.isSelected()) {
  119.                 area.setTransferHandler(null);
  120.             } else {
  121.                 area.setTransferHandler(th);
  122.             }
  123.         }
  124.     }
  126.     private TransferHandler handler = new TransferHandler() {
  127.         public boolean canImport(TransferHandler.TransferSupport support) {
  128.             if (!support.isDataFlavorSupported(DataFlavor.javaFileListFlavor)) {
  129.                 return false;
  130.             }
  132.             if (copyItem.isSelected()) {
  133.                 boolean copySupported = (COPY & support.getSourceDropActions()) == COPY;
  135.                 if (!copySupported) {
  136.                     return false;
  137.                 }
  139.                 support.setDropAction(COPY);
  140.             }
  142.             return true;
  143.         }
  145.         public boolean importData(TransferHandler.TransferSupport support) {
  146.             if (!canImport(support)) {
  147.                 return false;
  148.             }
  150.             Transferable t = support.getTransferable();
  152.             try {
  153.                 java.util.List<File> l =
  154.                     (java.util.List<File>)t.getTransferData(DataFlavor.javaFileListFlavor);
  156.                 for (File f : l) {
  157.                     new Doc(f);
  158.                 }
  159.             } catch (UnsupportedFlavorException e) {
  160.                 return false;
  161.             } catch (IOException e) {
  162.                 return false;
  163.             }
  165.             return true;
  166.         }
  167.     };
  169.     private static void incr() {
  170.         left += 30;
  171.         top += 30;
  172.         if (top == 150) {
  173.             top = 0;
  174.         }
  175.     }
  177.     public TopLevelTransferHandlerDemo() {
  178.         super("TopLevelTransferHandlerDemo");
  179.         setJMenuBar(createDummyMenuBar());
  180.         getContentPane().add(createDummyToolBar(), BorderLayout.NORTH);
  182.         JSplitPane sp = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, list, dp);
  183.         sp.setDividerLocation(120);
  184.         getContentPane().add(sp);
  185.         //new Doc("sample.txt");
  186.         //new Doc("sample.txt");
  187.         //new Doc("sample.txt");
  189.         list.getSelectionModel().setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
  191.         list.addListSelectionListener(new ListSelectionListener() {
  192.             public void valueChanged(ListSelectionEvent e) {
  193.                 if (e.getValueIsAdjusting()) {
  194.                     return;
  195.                 }
  197.                 Doc val = (Doc)list.getSelectedValue();
  198.                 if (val != null) {
  199.                     val.select();
  200.                 }
  201.              }
  202.         });
  204.         final TransferHandler th = list.getTransferHandler();
  206.         nullItem.addActionListener(new ActionListener() {
  207.             public void actionPerformed(ActionEvent ae) {
  208.                 if (nullItem.isSelected()) {
  209.                     list.setTransferHandler(null);
  210.                 } else {
  211.                     list.setTransferHandler(th);
  212.                 }
  213.             }
  214.         });
  215.         thItem.addActionListener(new ActionListener() {
  216.             public void actionPerformed(ActionEvent ae) {
  217.                 if (thItem.isSelected()) {
  218.                     setTransferHandler(handler);
  219.                 } else {
  220.                     setTransferHandler(null);
  221.                 }
  222.             }
  223.         });
  224.         dp.setTransferHandler(handler);
  225.     }
  227.     private static void createAndShowGUI(String[] args) {
  228.         try {
  229.             UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
  230.         } catch (Exception e) {
  231.         }
  233.         TopLevelTransferHandlerDemo test = new TopLevelTransferHandlerDemo();
  234.         test.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  235.         if (DEMO) {
  236.             test.setSize(493, 307);
  237.         } else {
  238.             test.setSize(800, 600);
  239.         }
  240.         test.setLocationRelativeTo(null);
  241.         test.setVisible(true);
  242.         test.list.requestFocus();
  243.     }
  245.     public static void main(final String[] args) {
  246.         SwingUtilities.invokeLater(new Runnable() {
  247.             public void run() {
  248.                 //Turn off metal's use of bold fonts
  249.                 UIManager.put("swing.boldMetal", Boolean.FALSE);
  250.                 createAndShowGUI(args);
  251.             }
  252.         });
  253.     }
  255.     private JToolBar createDummyToolBar() {
  256.         JToolBar tb = new JToolBar();
  257.         JButton b;
  258.         b = new JButton("New");
  259.         b.setRequestFocusEnabled(false);
  260.         tb.add(b);
  261.         b = new JButton("Open");
  262.         b.setRequestFocusEnabled(false);
  263.         tb.add(b);
  264.         b = new JButton("Save");
  265.         b.setRequestFocusEnabled(false);
  266.         tb.add(b);
  267.         b = new JButton("Print");
  268.         b.setRequestFocusEnabled(false);
  269.         tb.add(b);
  270.         b = new JButton("Preview");
  271.         b.setRequestFocusEnabled(false);
  272.         tb.add(b);
  273.         tb.setFloatable(false);
  274.         return tb;
  275.     }
  277.     private JMenuBar createDummyMenuBar() {
  278.         JMenuBar mb = new JMenuBar();
  279.         mb.add(createDummyMenu("File"));
  280.         mb.add(createDummyMenu("Edit"));
  281.         mb.add(createDummyMenu("Search"));
  282.         mb.add(createDummyMenu("View"));
  283.         mb.add(createDummyMenu("Tools"));
  284.         mb.add(createDummyMenu("Help"));
  286.         JMenu demo = new JMenu("Demo");
  287.         demo.setMnemonic(KeyEvent.VK_D);
  288.         mb.add(demo);
  290.         thItem = new JCheckBoxMenuItem("Use Top-Level TransferHandler");
  291.         thItem.setMnemonic(KeyEvent.VK_T);
  292.         demo.add(thItem);
  294.         nullItem = new JCheckBoxMenuItem("Remove TransferHandler from List and Text");
  295.         nullItem.setMnemonic(KeyEvent.VK_R);
  296.         demo.add(nullItem);
  298.         copyItem = new JCheckBoxMenuItem("Use COPY Action");
  299.         copyItem.setMnemonic(KeyEvent.VK_C);
  300.         demo.add(copyItem);
  302.         return mb;
  303.     }
  305.     private JMenu createDummyMenu(String str) {
  306.         JMenu menu = new JMenu(str);
  307.         JMenuItem item = new JMenuItem("[Empty]");
  308.         item.setEnabled(false);
  309.         menu.add(item);
  310.         return menu;
  311.     }
  312. }