Drag cursor not changing, but drop succeeding.

[B Atkins]

I've got a JTree as a drop target. I can drag leaf elements around within the tree just fine, and the cursor changes as appropriate when it's over a legal vs. illegal drop location. I have another drag source which is a JList in the same layout. I can drag from there and successfully drop onto the JTree (the list is NOT a drop target, btw). However, the cursor never changes when the drag is from the JList, it always shows a no-drop icon. I can drop, and the elements are successfully copied, but the cursor never changes. What am I doing wrong here?

I also want to control the type of cursor shown based on the drag source. If the drag comes from the JList, it will only ever be a copy, never a move. Hence, I want to always show the copy cursor, regardless of what meta-keys the user may be using, attempting to change the type of drag and drop. The intra-JTree DnD, however, can be either a move or copy, as normal. Can I accomplish this at the Swing level, or do I have to resort to an AWT solution? Can the two live together?

Thanks!
Brian

[Craig Wood]

Can I accomplish this at the Swing level,
Yes.
or do I have to resort to an AWT solution?
No.
Can the two live together?
Sometimes, yes.

import java.awt.*;
import java.awt.datatransfer.*;
import java.io.IOException;
import javax.swing.*;
import javax.swing.tree.*;

public class DropControl {
    private JScrollPane getLeft() {
        JTree tree = new JTree();
        expandTree(tree);
        tree.getSelectionModel()
            .setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        tree.setDragEnabled(true);
        tree.setDropMode(DropMode.ON_OR_INSERT);
        tree.setTransferHandler(new TreeTransferHandler());
        return new JScrollPane(tree);
    }

    private void expandTree(JTree tree) {
        DefaultMutableTreeNode root =
            (DefaultMutableTreeNode)tree.getModel().getRoot();
        java.util.Enumeration e = root.breadthFirstEnumeration();
        while(e.hasMoreElements()) {
            DefaultMutableTreeNode node =
                (DefaultMutableTreeNode)e.nextElement();
            if(node.isLeaf()) continue;
            int row = tree.getRowForPath(new TreePath(node.getPath()));
            tree.expandRow(row);
        }
    }

    private JScrollPane getRight() {
        String[] items = {
            "Alabama", "Alaska", "California", "Florida", "Rhode Island"
        };
        DefaultListModel model = new DefaultListModel();
        for(int i = 0; i < items.length; i++) {
            model.add(i, items[i]);
        }
        JList list = new JList(model);
        list.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
        list.setDragEnabled(true);
        list.setTransferHandler(listHandler);
        return new JScrollPane(list);
    }

    private TransferHandler listHandler = new TransferHandler() {
        public boolean canImport(TransferHandler.TransferSupport support) {
            return false;
        }

        protected Transferable createTransferable(JComponent c) {
            String s = (String)((JList)c).getSelectedValue();
            return new StringSelection(s);
        }

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

    public static void main(String[] args) {
        DropControl test = new DropControl();
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setLayout(new GridBagLayout());
        GridBagConstraints gbc = new GridBagConstraints();
        gbc.weightx = 1.0;
        gbc.weighty = 1.0;
        gbc.fill = GridBagConstraints.BOTH;
        f.add(test.getLeft(), gbc);
        f.add(test.getRight(), gbc);
        f.setSize(400,400);
        f.setLocation(100,100);
        f.setVisible(true);
    }
}

class TreeTransferHandler extends TransferHandler {
    DataFlavor stringFlavor = DataFlavor.stringFlavor;

    public boolean canImport(TransferHandler.TransferSupport support) {
        if(!support.isDrop() ||              // avoid paste ops
           !support.isDataFlavorSupported(stringFlavor)) {
            return false;
        }
        support.setShowDropLocation(true);
        if(support.getDropAction() == MOVE) {
            // Allow MOVE-actions only for leaf nodes.
            JTree tree = (JTree)support.getComponent();
            TreePath selPath = tree.getSelectionPath();
            TreeNode selNode = (TreeNode)selPath.getLastPathComponent();
            if(!selNode.isLeaf()) {
                return false;
            }
            // Do not allow a drop on the selected/source node.
            JTree.DropLocation dropLoc =
                (JTree.DropLocation)support.getDropLocation();
            TreePath dropPath = dropLoc.getPath();
            if(tree.isPathSelected(dropPath)) {
                return false;
            }
        }
        return true;
    }

    protected Transferable createTransferable(JComponent c) {
        JTree tree = (JTree)c;
        TreePath path = tree.getSelectionPath();
        DefaultMutableTreeNode node =
            (DefaultMutableTreeNode)path.getLastPathComponent();
        String data = (String)node.getUserObject();
        return new StringSelection(data);
    }

    protected void exportDone(JComponent source,
                              Transferable data, int action) {
        if((action & MOVE) == MOVE) {
            JTree tree = (JTree)source;
            TreePath path = tree.getSelectionPath();
            DefaultMutableTreeNode node =
                (DefaultMutableTreeNode)path.getLastPathComponent();
            DefaultTreeModel model = (DefaultTreeModel)tree.getModel();
            model.removeNodeFromParent(node);
        }
    }

    public int getSourceActions(JComponent c) {
        return COPY_OR_MOVE;
    }

    public boolean importData(TransferHandler.TransferSupport support) {
        if(!canImport(support)) {
            return false;
        }
        // Unpack transferable data.
        Transferable t = support.getTransferable();
        String data;
        try {
            data = (String)t.getTransferData(stringFlavor);
        } catch(UnsupportedFlavorException e) {
            System.out.println("unsupported flavor: " + e.getMessage());
            return false;
        } catch(IOException e) {
            System.out.println("read error: " + e.getMessage());
            return false;
        }
        // Get drop location.
        JTree.DropLocation dropLoc =
            (JTree.DropLocation)support.getDropLocation();
        TreePath path = dropLoc.getPath();
        DefaultMutableTreeNode parent =
            (DefaultMutableTreeNode)path.getLastPathComponent();
        int childIndex = dropLoc.getChildIndex(); // DropMode.INSERT
        if(childIndex == -1) {                    // DropMode.ON
            childIndex = parent.getChildCount();
        }
        // Insert new node.
        DefaultMutableTreeNode child = new DefaultMutableTreeNode(data);
        JTree tree = (JTree)support.getComponent();
        DefaultTreeModel model = (DefaultTreeModel)tree.getModel();
        model.insertNodeInto(child, parent, childIndex);
        return true;
    }
}

If you want the cursor to show the copy_cursor inside/over the list you can return true from canImport and override importData to return false inside listHandler.

public boolean canImport(TransferHandler.TransferSupport support) {
    return true;
}

public boolean importData(TransferHandler.TransferSupport support) {
    return false;
}

[Maneesh Godbole]

B Atkins wrote: Can the two live together?

As you probably already know AWT is "heavyweight" where as Swing is it's "lightweight" cousin.
Check out this article on why it's not a good idea to mix up the two.

[B Atkins]

Thanks! I discovered that limiting the source to just COPY will get you the COPY cursor, like you demonstrated. Somewhere along the line the cursor remaining no-drop even when over a valid drop zone, and even with a successful drop, went away.

I already have a working system with a somewhat complex transfer, in that objects coming from the JList are one type, while objects moving around in the JTree are another. When the transferable comes in from the JList, it gets converted to the appropriate type for insertion into the JTree. I do this with a custom DataFlavor and Transferable. The problem was just with the cursor not behaving correctly, which has since resolved.