Java从Swing拖放到JavaFX

我正在尝试将自定义对象从JPanel拖放到JavaFX场景。
为了实现这一点，我创建了一个带有自定义对象和自定义TransferHandler的简单应用程序。在本例中，我的问题是，当我在

dragboard=event.getDragboard（）设置断点时，JavaFX dragboard只有内容onDragOver（）

或

ondragdroped（）

方法中的code>。在断点处停止后，我可以删除断点，并且DnD每次都在工作

有人能帮我在没有断点的情况下工作吗

先谢谢你

这是我的密码：

肌体

肌对象

swingndtofx

导入javafx.application.Platform；
导入javafx.embed.swing.JFXPanel；
导入javafx.scene.scene；
导入javafx.scene.control.Label；
导入javafx.scene.input.DataFormat；
导入javafx.scene.input.Dragboard；
导入javafx.scene.input.TransferMode；
导入javafx.scene.layout.GridPane；
导入javax.swing.*；
导入java.awt.*；
导入java.awt.datatransfer.DataFlavor；
导入java.awt.datatransfer.transfer；
导入java.awt.dnd.DnDConstants；
导入java.awt.dnd.DragGestureListener；
导入java.awt.dnd.DragSource；
导入java.awt.dnd.DropTarget；
导入java.awt.dnd.DropTargetAdapter；
导入java.awt.dnd.DropTargetDropEvent；
导入java.awt.dnd.DropTargetListener；
导入java.awt.event.MouseAdapter；
导入java.awt.event.MouseEvent；
导入java.text.simpleDataFormat；
导入java.util.Date；
公共类swingndtofx
{
专用JLabel状态标签；
公共静态void main（字符串[]args）
{
新的swingndtofx（）.init（）；
}
私有void init（）
{
最终JFrame=新JFrame（）；
框架设置尺寸（1000500）；
frame.setContentPane（createPanel（））；
frame.setDefaultCloseOperation（WindowConstants.EXIT_ON_CLOSE）；
frame.setVisible（true）；
}
私有JPanel createPanel（）
{
最终JPanel小组；
最终JPanel太空小组；
最终尺寸；
panel=newjpanel（newborderlayout（））；
spacePanel=newjpanel（newborderlayout（））；
尺寸=新尺寸（300500）；
statusLabel=新的JLabel（）；
spacePanel.setBackground（颜色：红色）；
spacePanel.add（statusLabel、BorderLayout.CENTER）；
添加（createDragPanel（维度），BorderLayout.WEST）；
panel.add（spacePanel，BorderLayout.CENTER）；
panel.add（createDropPanel（维度），BorderLayout.EAST）；
返回面板；
}
专用JPanel createDragPanel（最终尺寸）
{
最终JPanel dragPanel；
最终JLabel-dragLabel；
最终Draggesturelelistener dgl；
最终DragSource DragSource；
dragPanel=newjpanel（newgridlayout（））；
dragLabel=新JLabel（“拖动我”）；
dragSource=新的dragSource（）；
dgl=dge->
{
final MyObject obj=新的MyObject（dragLabel.getText（））；
最终MYOBJECTTRANSABLE=新MYOBJECTTRANSABLE（obj）；
dge.startDrag（无效，可转让）；
};
dragSource.CreateDefaultDraggestureRecogener（dragLabel，DnDConstants.ACTION_COPY，dgl）；
setTransferHandler（新的TransferHandler（“dragLabel”））；
dragLabel.addMouseListener（新的MouseAdapter（）
{
@凌驾
公共无效鼠标按下（MouseEvent e）
{
最终JComponent c=（JComponent）e.getSource（）；
最终TransferHandler th=c.getTransferHandler（）；
exportAsDrag（c，e，TransferHandler.COPY）；
}
});
拖板。背景（颜色。青色）；
dragPanel.setPreferredSize（尺寸）；
dragPanel.add（dragLabel）；
返回拖板；
}
专用JPanel createDropPanel（最终尺寸）
{
最终JPanel dropPanel；
最终JLabel-dropLabel；
最终DropTargetListener dtl；
dropPanel=新的JPanel（新的GridLayout（0,1））；
dropLabel=新的JLabel（“放在这里（摆动）”；
dtl=新的DropTargetAdapter（）
{
@凌驾
公共作废删除（DropTargetDropEvent dtde）
{
最终可转让；
最终数据风味[]数据风味；
尝试
{
transferable=dtde.getTransferable（）；
dataFlavors=transferable.getTransferDataFlavors（）；
for（int i=0；i
{
最后一幕；
最终网格窗格；
最终标签；
最终标签名称；
窗玻璃
public class MyObject
{
    private final String text;


    public MyObject(String text)
    {
        this.text = text;
    }


    public String getText()
    {
        return text;
    }
}  

import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.datatransfer.UnsupportedFlavorException;
import java.io.IOException;


public class MyObjectTransferable implements Transferable
{
    public static final DataFlavor DATAFLAVOR_MYOBJECT = new DataFlavor(MyObject.class, "myObject");

    private final MyObject obj;


    public MyObjectTransferable(MyObject obj)
    {
        this.obj = obj;
    }


    @Override
    public DataFlavor[] getTransferDataFlavors()
    {
        return new DataFlavor[] {DATAFLAVOR_MYOBJECT};
    }


    @Override
    public boolean isDataFlavorSupported(DataFlavor flavor)
    {
        return DATAFLAVOR_MYOBJECT.equals(flavor);
    }


    @Override
    public Object getTransferData(DataFlavor flavor) throws UnsupportedFlavorException, IOException
    {
        return DATAFLAVOR_MYOBJECT.equals(flavor) ? obj : null;
    }
}

import javafx.application.Platform;
import javafx.embed.swing.JFXPanel;
import javafx.scene.Scene;
import javafx.scene.control.Label;
import javafx.scene.input.DataFormat;
import javafx.scene.input.Dragboard;
import javafx.scene.input.TransferMode;
import javafx.scene.layout.GridPane;

import javax.swing.*;
import java.awt.*;
import java.awt.datatransfer.DataFlavor;
import java.awt.datatransfer.Transferable;
import java.awt.dnd.DnDConstants;
import java.awt.dnd.DragGestureListener;
import java.awt.dnd.DragSource;
import java.awt.dnd.DropTarget;
import java.awt.dnd.DropTargetAdapter;
import java.awt.dnd.DropTargetDropEvent;
import java.awt.dnd.DropTargetListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.text.SimpleDateFormat;
import java.util.Date;


public class SwingDnDtoFX
{
    private JLabel statusLabel;


    public static void main(String[] args)
    {
        new SwingDnDtoFX().init();
    }


    private void init()
    {
        final JFrame frame = new JFrame();

        frame.setSize(1000, 500);
        frame.setContentPane(createPanel());
        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
        frame.setVisible(true);
    }


    private JPanel createPanel()
    {
        final JPanel    panel;
        final JPanel    spacePanel;
        final Dimension dimension;

        panel       = new JPanel(new BorderLayout());
        spacePanel  = new JPanel(new BorderLayout());
        dimension   = new Dimension(300, 500);
        statusLabel = new JLabel();

        spacePanel.setBackground(Color.RED);
        spacePanel.add(statusLabel, BorderLayout.CENTER);

        panel.add(createDragPanel(dimension), BorderLayout.WEST);
        panel.add(spacePanel, BorderLayout.CENTER);
        panel.add(createDropPanel(dimension), BorderLayout.EAST);

        return panel;
    }


    private JPanel createDragPanel(final Dimension dimension)
    {
        final JPanel                dragPanel;
        final JLabel                dragLabel;
        final DragGestureListener   dgl;
        final DragSource            dragSource;

        dragPanel  = new JPanel(new GridLayout());
        dragLabel  = new JLabel("Drag me");
        dragSource = new DragSource();

        dgl = dge ->
        {
            final MyObject             obj          = new MyObject(dragLabel.getText());
            final MyObjectTransferable transferable = new MyObjectTransferable(obj);

            dge.startDrag(null, transferable);
        };

        dragSource.createDefaultDragGestureRecognizer(dragLabel, DnDConstants.ACTION_COPY, dgl);

        dragLabel.setTransferHandler(new TransferHandler("dragLabel"));
        dragLabel.addMouseListener(new MouseAdapter()
        {
            @Override
            public void mousePressed(MouseEvent e)
            {
                final JComponent      c  = (JComponent) e.getSource();
                final TransferHandler th = c.getTransferHandler();

                th.exportAsDrag(c, e, TransferHandler.COPY);
            }
        });

        dragPanel.setBackground(Color.CYAN);
        dragPanel.setPreferredSize(dimension);
        dragPanel.add(dragLabel);

        return dragPanel;
    }


    private JPanel createDropPanel(final Dimension dimension)
    {
        final JPanel             dropPanel;
        final JLabel             dropLabel;
        final DropTargetListener dtl;

        dropPanel = new JPanel(new GridLayout(0, 1));
        dropLabel = new JLabel("Drop here (Swing)");
        dtl       = new DropTargetAdapter()
        {
            @Override
            public void drop(DropTargetDropEvent dtde)
            {
                final Transferable transferable;
                final DataFlavor[] dataFlavors;

                try
                {
                    transferable = dtde.getTransferable();
                    dataFlavors  = transferable.getTransferDataFlavors();

                    for (int i = 0; i < dataFlavors.length; i++)
                    {
                        if (MyObjectTransferable.DATAFLAVOR_MYOBJECT.equals(dataFlavors[i]))
                        {
                            final MyObject data;

                            dtde.acceptDrop(dtde.getDropAction());

                            data = (MyObject) transferable.getTransferData(dataFlavors[i]);

                            showStatus(data, "Swing");

                            dtde.dropComplete(true);
                        }
                    }
                } 
                catch (Exception e)
                {
                    e.printStackTrace();
                    dtde.rejectDrop();
                }
            }
        };
        new DropTarget(dropLabel, dtl);

        dropLabel.setOpaque(true);
        dropLabel.setBackground(Color.CYAN);

        dropPanel.setPreferredSize(dimension);
        dropPanel.add(dropLabel);
        dropPanel.add(createFX());

        return dropPanel;
    }


    private JFXPanel createFX()
    {
        final JFXPanel fxPanel;

        fxPanel = new JFXPanel();

        Platform.runLater(() ->
        {
            final Scene    scene;
            final GridPane pane;
            final Label    label;
            final Label    title;

            pane  = new GridPane();
            scene = new Scene(pane);
            label = new Label();
            title = new Label("Drop here (JavaFX)");

            pane.add(title, 0, 0);
            pane.add(label, 0, 1);
            pane.setOnDragOver(event ->
            {
                final Dragboard  dragboard;
                final DataFormat dataFormat;

                dragboard  = event.getDragboard();
                dataFormat = DataFormat.lookupMimeType("application/x-java-serialized-object");

                if (dragboard.hasContent(dataFormat))
                    event.acceptTransferModes(TransferMode.COPY);

                event.consume();
            });
            pane.setOnDragDropped(event ->
            {
                final Dragboard  dragboard;
                final DataFormat dataFormat;

                boolean success = false;

                dragboard  = event.getDragboard();
                dataFormat = DataFormat.lookupMimeType("application/x-java-serialized-object");

                if (dragboard.hasContent(dataFormat))
                {
                    final Object   content;
                    final MyObject data;

                    content = dragboard.getContent(dataFormat);

                    if (content instanceof MyObject)
                    {
                        data = (MyObject) content;

                        label.setText(data.getText());
                        SwingUtilities.invokeLater(() -> showStatus(data, "JavaFX"));

                        success = true;
                    }
                }

                event.setDropCompleted(success);
                event.consume();
            });

            fxPanel.setScene(scene);
        });

        return fxPanel;
    }


    private void showStatus(MyObject data, String framework)
    {
        final String date = new SimpleDateFormat("HH:mm:ss").format(new Date());

        statusLabel.setText(date + " >> " + framework + " >> " + data.getText());
    }
}

pane.setOnDragOver(event ->
{
    final Dragboard  dragboard;
    final DataFormat dataFormat;

    dragboard  = event.getDragboard();
    dataFormat = DataFormat.lookupMimeType("application/x-java-serialized-object");

    for (DataFormat df : dragboard.getContentTypes())
    {
        // Do nothing...
    }

    if (dragboard.hasContent(dataFormat))
        event.acceptTransferModes(TransferMode.COPY);

    event.consume();
});