Uploaded image for project: 'JDK'
  1. JDK
  2. JDK-8274751

Drag And Drop hangs on Windows

    XMLWordPrintable

    Details

    • Subcomponent:
    • Introduced In Build:
      b01
    • Introduced In Version:
    • CPU:
      x86_64
    • OS:
      windows_10

      Description

      ADDITIONAL SYSTEM INFORMATION :
      Windows 10 x64

      A DESCRIPTION OF THE PROBLEM :
      The drag and drop operation from Java application to Windows explorer hangs the application.
      This worked before JDK 8u301 and JDK 11.0.12. It seems like this issue is caused by https://bugs.openjdk.java.net/browse/JDK-8262446



      STEPS TO FOLLOW TO REPRODUCE THE PROBLEM :
      1. Start the attached application
      2. Drag a file from the attached application
      3. Drop it in a Windows explorer

      EXPECTED VERSUS ACTUAL BEHAVIOR :
      EXPECTED -
      The dragged file should appear in the Windows explorer
      ACTUAL -
      The dragged file does not show up in the drop area and the client is locked.

      ---------- BEGIN SOURCE ----------
      package com.test.testing;

      import java.awt.AWTEvent;
      import java.awt.EventQueue;
      import java.awt.Toolkit;
      import java.awt.datatransfer.DataFlavor;
      import java.awt.datatransfer.Transferable;
      import java.awt.datatransfer.UnsupportedFlavorException;
      import java.io.File;
      import java.io.IOException;
      import java.lang.reflect.Method;
      import java.util.ArrayList;
      import java.util.Arrays;
      import java.util.List;
      import java.util.concurrent.ExecutionException;
      import java.util.concurrent.Future;
      import java.util.concurrent.Semaphore;
      import java.util.concurrent.atomic.AtomicReference;
      import java.util.stream.Collectors;

      import javax.swing.JComponent;
      import javax.swing.JDialog;
      import javax.swing.JFrame;
      import javax.swing.JScrollPane;
      import javax.swing.JTextField;
      import javax.swing.JTree;
      import javax.swing.SwingUtilities;
      import javax.swing.SwingWorker;
      import javax.swing.TransferHandler;
      import javax.swing.tree.DefaultMutableTreeNode;
      import javax.swing.tree.DefaultTreeModel;
      import javax.swing.tree.TreePath;

      public class App implements Runnable {

      // Set this to true to reproduce the problem
      private static final boolean ENABLE_PROBLEM = true;

      private DefaultMutableTreeNode root;
      private DefaultTreeModel treeModel;
      private JTree tree;

      @Override
      public void run() {
      JFrame frame = new JFrame("File Browser");
      frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

      File fileRoot = File.listRoots()[0];
      root = new DefaultMutableTreeNode(new FileNode(fileRoot));
      treeModel = new DefaultTreeModel(root);

      tree = new JTree(treeModel);
      tree.setShowsRootHandles(true);
      tree.setDragEnabled(true);
      tree.setTransferHandler(new FileTransferHandler());

      JScrollPane scrollPane = new JScrollPane(tree);

      frame.add(scrollPane);
      frame.setLocationByPlatform(true);
      frame.setSize(640, 480);
      frame.setVisible(true);

      CreateChildNodes ccn = new CreateChildNodes(fileRoot, root);
      new Thread(ccn).start();
      }

      public class CreateChildNodes implements Runnable {

      private DefaultMutableTreeNode root;
      private File fileRoot;

      public CreateChildNodes(File fileRoot, DefaultMutableTreeNode root) {
      this.fileRoot = fileRoot;
      this.root = root;
      }

      @Override
      public void run() {
      createChildren(fileRoot, root);
      }

      private void createChildren(File fileRoot, DefaultMutableTreeNode node) {
      File[] files = fileRoot.listFiles();
      if (files == null)
      return;

      for (File file : files) {
      DefaultMutableTreeNode childNode = new DefaultMutableTreeNode(new FileNode(file));
      node.add(childNode);
      if (file.isDirectory()) {
      createChildren(file, childNode);
      }
      }
      }
      }

      public class FileNode {

      private File file;

      public FileNode(File file) {
      this.file = file;
      }

      @Override
      public String toString() {
      String name = file.getName();
      if (name.equals("")) {
      return file.getAbsolutePath();
      } else {
      return name;
      }
      }
      }

      private class FileTransferHandler extends TransferHandler {

      private static final long serialVersionUID = 1L;

      @Override
      protected Transferable createTransferable(JComponent c) {
      JTree list = (JTree) c;
      List<File> files = new ArrayList<File>();
      for (TreePath path : list.getSelectionPaths()) {
      files.add(new File(Arrays.stream(path.getPath()).map(Object::toString)
      .collect(Collectors.joining(File.separator))));
      }
      return new FileTransferable(files);
      }

      @Override
      public int getSourceActions(JComponent c) {
      return COPY;
      }
      }

      private class FileTransferable implements Transferable {

      // Just a list of files that should be "downloaded"
      private List<File> files;

      private AtomicReference<List<File>> mDownloadedFiles = new AtomicReference<List<File>>();
      private boolean mHasFetchedFiles;

      public FileTransferable(List<File> files) {
      this.files = files;
      }

      public DataFlavor[] getTransferDataFlavors() {
      return new DataFlavor[] { DataFlavor.javaFileListFlavor };
      }

      public boolean isDataFlavorSupported(DataFlavor flavor) {
      return flavor.equals(DataFlavor.javaFileListFlavor);
      }

      public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException {
      if (!isDataFlavorSupported(flavor)) {
      throw new UnsupportedFlavorException(flavor);
      }

      List<File> data = mDownloadedFiles.get();
      if (data == null) {
      data = fetchFileData();
      if (data == null) {
      System.out.println("Unsupported operation!");
      throw new UnsupportedFlavorException(flavor);
      }
      }
      return data;
      }

      private synchronized List<File> fetchFileData() {
      if (!mHasFetchedFiles) {
      mHasFetchedFiles = true;
      try {
      DownloadableWorker downloadable = new DownloadableWorker(files);
      // Start the download in background
      downloadable.execute();

      // Wait for the download to complete
      mDownloadedFiles.set(new EventDispatchThreadUtil().futureGet(downloadable));
      } catch (Exception e) {
      throw new RuntimeException(e);
      }
      }
      return mDownloadedFiles.get();
      }
      }

      private static class DownloadableWorker extends SwingWorker<List<File>, Object> {
      private List<File> files;

      public DownloadableWorker(List<File> files) {
      this.files = files;

      // Adding this will alter the events so we will block the application for ever
      // when dropping file into a windows folder
      if (ENABLE_PROBLEM)
      {
      MyProgressDialog myProgressDialog = new MyProgressDialog();
      myProgressDialog.setVisible(true);
      }
      }

      @Override
      protected List<File> doInBackground() throws Exception {
      // We have a list of files that needs to be downloaded, simulated here with a
      // thread sleep
      try {
      System.out.println("-- Starting download");
      Thread.sleep(2000);
      System.out.println("-- Files downloaded");
      } catch (InterruptedException e) {
      e.printStackTrace();
      }
      return files;
      }
      }

      private static class MyProgressDialog extends JDialog {
      private static final long serialVersionUID = 1L;

      public MyProgressDialog() {
      JTextField textField = new JTextField("Some progress...");
      getContentPane().add(textField);
      }
      }

      private static class EventDispatchThreadUtil
      {
      private static final Runnable NOOP_RUNNABLE = new Runnable()
      {
      @Override
      public void run()
      {
      // Do nothing
      }
      };
      private static final Method DISPATCH_EVENT_METHOD;
      static
      {
      Method m = null;
      try
      {
      m = EventQueue.class.getDeclaredMethod("dispatchEvent", AWTEvent.class);
      m.setAccessible(true);
      }
      catch (Exception e)
      {
      throw new RuntimeException(e);
      }
      DISPATCH_EVENT_METHOD = m;
      }

      /**
      * Gets one event from the event queue and then dispatches it. If the
      * event queue is empty then the call will block until an event is
      * available. This method must be called by the event dispatch thread.
      */
      public void pumpOneEvent() throws InterruptedException
      {
      if (!SwingUtilities.isEventDispatchThread())
      {
      String msg = "Must be called from the event dispatch thread.";
      throw new IllegalStateException(msg);
      }
      EventQueue eventQueue = Toolkit.getDefaultToolkit().getSystemEventQueue();
      // blocks when the event queue is empty.
      AWTEvent event = eventQueue.getNextEvent();
      try
      {
      DISPATCH_EVENT_METHOD.invoke(eventQueue, event);
      }
      catch (Exception e)
      {
      throw new RuntimeException(e);
      }
      }

      /**
      * If a call to this method is made from the event dispatch thread then it
      * will simulate a blocking call to Future#get() by creating a helper thread
      * that blocks on the get call. While the call is being performed the event
      * queue is pumped by the thread calling this method. When the call is done
      * the helper thread notifies this thread which then returns. If the call is
      * made by another thread then the get-method of the given future will be
      * called directly.
      * @param <T> the generic type of the future
      * @param future the future to get the result from
      * @return the result of the future
      */
      public <T> T futureGet(final Future<T> future)
      throws InterruptedException, ExecutionException
      {
      if (!EventQueue.isDispatchThread())
      {
      return future.get();
      }

      final Semaphore semaphore = new Semaphore(1);
      semaphore.acquire();

      // start a helper thread that will block for us
      Thread t = new Thread(new Runnable()
      {
      @Override
      public void run()
      {
      try
      {
      future.get();
      }
      catch (Exception e)
      {
      e.printStackTrace();
      }
      finally
      {
      release(semaphore);
      }
      }
      });
      t.start();

      acquire(semaphore);

      // our helper thread finished successfully
      T result = future.get();

      return result;
      }

      /**
      * Will block in the call until a permit is acquired from the semaphore.
      * May be called from any thread. If called from the event dispatch thread
      * then we will as long as we fail to tryAcquire a permit, pump one event on
      * the event dispatch thread and the repeat the process until a permit
      * has been acquired. However, when we pump the event dispatch queue, if
      * there is no events on the queue then we will block on the queue until
      * an event arrives. This method should be used together with
      * {@link #release(Semaphore)} that additionally to releasing a permit also
      * posts a noop event on the event dispatch queue and by that wakes us up
      * if we're blocking.
      * @param semaphore the semaphore to acquire a permit from
      * @throws InterruptedException if the blocking thread is interrupted
      */
      public void acquire(Semaphore semaphore) throws InterruptedException
      {
      if (!EventQueue.isDispatchThread())
      {
      semaphore.acquire();
      return;
      }

      // pump the event queue until the thread exits controlled
      while (!semaphore.tryAcquire())
      {
      pumpOneEvent();
      }
      }

      /**
      * Releases one permit on the given semaphore and pokes the event dispatch
      * thread. May be called from any thread. Will also post a noop event to
      * the event dispatch queue. Should be used together with
      * {@link #acquire(Semaphore)}.
      * @param semaphore
      */
      public void release(Semaphore semaphore)
      {
      semaphore.release();
      // unblock the event dispatch thread by dispatching
      // a noop runnable on the event dispatch thread
      EventQueue.invokeLater(NOOP_RUNNABLE);
      }
      }

      public static void main(String[] args) {
      SwingUtilities.invokeLater(new App());
      }
      }
      ---------- END SOURCE ----------

      FREQUENCY : always


        Attachments

          Issue Links

            Activity

              People

              Assignee:
              dmarkov Dmitry Markov
              Reporter:
              webbuggrp Webbug Group
              Votes:
              0 Vote for this issue
              Watchers:
              3 Start watching this issue

                Dates

                Created:
                Updated: