Subtree in JTree

[Jeevan Anand]

JTree has root folder invisible. It has folders as child nodes of tree called A, B, C, D.

A, B can contain only leaf nodes.

C, D can contain child nodes as folder and those child folders will have leaf nodes.

The problem is I want C/D should be treated as single tree i.e. user can not move any leaf node of C/D tree to any other folder like A/B...that is 'p' can be moved to Folder2 but not to folder 'A'/ 'B'...How to make these type of settings??

  
-A
  |-x
  |-y
-B
  |-x
  |-y
-C
  |-Folder1
      |-p
      |-q
  |-Folder2
      |-r
      |-s
 
  

Kindly help me.
[ July 02, 2008: Message edited by: Jeevan Anand ]

[Craig Wood]

I tried to keep this simple to show/emphasize how to customize the drop behavior. There are so many possibilities that it's difficult to say much about it.

import java.awt.*;
import java.awt.datatransfer.*;
import java.io.IOException;
import javax.swing.*;
import javax.swing.tree.*;
 
public class TreeLimits {
    private JScrollPane getContent() {
        JTree tree = getTree();
        //tree.setRootVisible(false);
        tree.getSelectionModel().setSelectionMode(
            TreeSelectionModel.SINGLE_TREE_SELECTION);
        tree.setDragEnabled(true);
        tree.setDropMode(DropMode.ON_OR_INSERT);
        tree.setTransferHandler(new LimitHandler());
        expandTree(tree);
        return new JScrollPane(tree);
    }
 
    private JTree getTree() {
        String[][] ids = {
            { "A", "w", "x" }, { "B", "y", "z" }, { "C" },
            { "Folder 1", "p", "q" }, { "Folder 2", "r", "s" }
        };
        DefaultMutableTreeNode root = new DefaultMutableTreeNode("root");
        DefaultMutableTreeNode n = null;
        for(int i = 0; i < ids.length; i++) {
            if(i < 3) {
                n = getNode(ids[i]);
                root.insert(n, i);
            } else {
                n.insert(getNode(ids[i]), i-3);
            }
        }
        DefaultTreeModel model = new DefaultTreeModel(root);
        return new JTree(model);        
    }
 
    private DefaultMutableTreeNode getNode(String[] s) {
        DefaultMutableTreeNode node = new DefaultMutableTreeNode(s[0]);
        for(int i = 1; i < s.length; i++) {
            node.insert(new DefaultMutableTreeNode(s[i]), i-1);
        }
        return node;
    }
 
    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);
        }
    }
 
    public static void main(String[] args) {
        TreeLimits test = new TreeLimits();
        JFrame f = new JFrame();
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.add(test.getContent());
        f.setSize(400,400);
        f.setLocation(200,200);
        f.setVisible(true);
    }
}
 
class LimitHandler extends TransferHandler {
    DefaultMutableTreeNode rangeLimit;
    boolean limitedDragUnderway = false;
 
    public boolean importData(TransferHandler.TransferSupport support) {
        if(!canImport(support)) {
            return false;
        }
 
        String data = null;
        try {
            Transferable t = support.getTransferable();
            data = (String)t.getTransferData(DataFlavor.stringFlavor);
        } catch(UnsupportedFlavorException ufe) {
            System.out.println("Bad flavor :" + ufe.getMessage());
        } catch(IOException ioe) {
            System.out.println("I/O error :" + ioe.getMessage());
        }
 
        if(support.isDrop()) {
            DefaultMutableTreeNode child = new DefaultMutableTreeNode(data);
            JTree.DropLocation dl =
                (JTree.DropLocation)support.getDropLocation();
            TreePath selectedPath = dl.getPath();
            DefaultMutableTreeNode parent =
                (DefaultMutableTreeNode)selectedPath.getLastPathComponent();
            int childIndex = dl.getChildIndex();
            // Okay to append node to end of level 2 nodes (folder 1 and
            // folder 2) but do not allow it to be dropped as child of
            // level 3 leaves.
            if(limitedDragUnderway && childIndex == -1
                                   && parent.getLevel() == 2) {
                childIndex = parent.getChildCount();
            }
            JTree tree = (JTree)support.getComponent();
            DefaultTreeModel model = (DefaultTreeModel)tree.getModel();
            model.insertNodeInto(child, parent, childIndex);
            return true;
        }
        return false;
    }
 
    public boolean canImport(TransferHandler.TransferSupport support) {
        if(!support.isDrop())
            return false;
 
        support.setShowDropLocation(true);
 
        if(!support.isDataFlavorSupported(DataFlavor.stringFlavor))
            return false;
 
        // Inspect the drop location.
        JTree.DropLocation dl =
            (JTree.DropLocation)support.getDropLocation();
        TreePath selectedPath = dl.getPath();
        DefaultMutableTreeNode node =
            (DefaultMutableTreeNode)selectedPath.getLastPathComponent();
        // Legal drop locations below rangeLimit must:
        // 1 - descend from rangelLimit node, and
        // 2 - not be the levelOne rangeLimit node.
        if(limitedDragUnderway) {
            boolean descendsFromLimit = rangeLimit.isNodeDescendant(node);
            boolean isLimit = node.equals(rangeLimit);
            if(!descendsFromLimit || isLimit)
                return false;
        } else {
            // Above rangelLimit allow drops only on level 1 nodes.
            if(node.getLevel() != 1)
                return false;
        }
 
        // Validate/set drop action.
        boolean moveSupported =
            (MOVE & support.getSourceDropActions()) == MOVE;
        if(moveSupported) {
            support.setDropAction(MOVE);
            return true;
        }
        return false;
    }
 
    protected Transferable createTransferable(JComponent c) {
        JTree tree = (JTree)c;
        TreePath path = tree.getSelectionPath();
        DefaultMutableTreeNode node =
            (DefaultMutableTreeNode)path.getLastPathComponent();
        int level = node.getLevel();
        // If level is 3 user is dragging the children below node C.
        // We want to restrict their movement so find the parent node
        // above which they may not be dropped and set the limit flag.
        if(level == 3) {
            rangeLimit = getLevel1Parent(node);
            limitedDragUnderway = true;
        }
        String userObject = node.getUserObject().toString();
        return new StringSelection(userObject);
    }
 
    private DefaultMutableTreeNode getLevel1Parent(DefaultMutableTreeNode n) {
        DefaultMutableTreeNode node = n.getPreviousNode();
        while(node.getLevel() > 1) {
            node = node.getPreviousNode();
        }
        return node;
    }
 
    protected void exportDone(JComponent c, Transferable t, int action) {
        limitedDragUnderway = false;  // reset flag
        if((action & MOVE) == MOVE) {
            JTree tree = (JTree)c;
            TreePath path = tree.getSelectionPath();
            if(path != null) {
                DefaultMutableTreeNode node =
                    (DefaultMutableTreeNode)path.getLastPathComponent();
                DefaultTreeModel model = (DefaultTreeModel)tree.getModel();
                model.removeNodeFromParent(node);
            }
        }
    }
 
    public int getSourceActions(JComponent c) {
        return MOVE;
    }
}

Edit: Most of the code in the TransferHandler was taken from the Drag and Drop tutorial.
[ July 04, 2008: Message edited by: Craig Wood ]