Results 1 to 3 of 3
  1. #1
    Melki is offline Member
    Join Date
    Jun 2008
    Posts
    20
    Rep Power
    0

    Default [SOLVED] Construct parents using tree path.

    I am getting the path of a leaf node which has three parents from a tree. Will it be possible to construct the parents of the leafnode in a new tree using that path.

    Kindly help me in this issue.Thank you.

  2. #2
    hardwired's Avatar
    hardwired is offline Senior Member
    Join Date
    Jul 2007
    Posts
    1,576
    Rep Power
    8

    Default

    Java Code:
    import java.awt.*;
    import java.awt.event.*;
    import java.util.Enumeration;
    import javax.swing.*;
    import javax.swing.tree.*;
    
    public class BuildingNodes implements ActionListener {
        JTree left;
        JTree right;
    
        public void actionPerformed(ActionEvent e) {
            if(left.getSelectionPath() != null) {
                moveNode(left, right);
            }
            if(right.getSelectionPath() != null) {
                moveNode(right, left);
            }
        }
    
         private void moveNode(JTree source, JTree target) {
            TreePath sourcePath = source.getSelectionPath();
            DefaultMutableTreeNode selectedNode =
                (DefaultMutableTreeNode)sourcePath.getLastPathComponent();
            // Selected node must be a leaf and must not exist in target.
            if(!selectedNode.isLeaf() ||
                    findNode(selectedNode.toString(), target) != null) {
                return;
            }
            String parentId =
                ((DefaultMutableTreeNode)selectedNode.getParent()).toString();
            DefaultMutableTreeNode targetParent =
                findTargetParent(sourcePath, target);
            DefaultMutableTreeNode child = null;
            // Find index of targetParent node value in sourcePath
            // and use the next deeper index for the node build.
            int numNodes = sourcePath.getPathCount();
            for(int i = 0; i < numNodes; i++) {
                Object o = sourcePath.getPathComponent(i);
                DefaultMutableTreeNode node = (DefaultMutableTreeNode)o;
                if(node.toString().equals(targetParent.toString())) {
                    // Found parent, use next path component
                    // index to start building child node.
                    child = buildNode(i+1, sourcePath);
                    break;
                }
            }
            // Append the child to the targetParent.
            DefaultTreeModel targetModel = (DefaultTreeModel)target.getModel();
            targetModel.insertNodeInto(child, targetParent,
                                       targetParent.getChildCount());
            // Expand the targetParent path to show child.
            expand(target, new TreePath(targetParent.getPath()));
            // Remove selectedNode from source.
            DefaultTreeModel sourceModel = (DefaultTreeModel)source.getModel();
            sourceModel.removeNodeFromParent(selectedNode);
        }
    
        /**
         * Search target tree for path elements of source tree.
         */
        private DefaultMutableTreeNode findTargetParent(TreePath path,
                                                        JTree tree) {
            DefaultMutableTreeNode root =
                (DefaultMutableTreeNode)tree.getModel().getRoot();
            // Start at maximum depth in path and look for a
            // matching node in tree. Return first match.
            int lastIndex = path.getPathCount()-1;
            for(int i = lastIndex; i >= 0; i--) {
                Object o = path.getPathComponent(i);
                String s = ((DefaultMutableTreeNode)o).toString();
                DefaultMutableTreeNode targetNode = findNode(s, tree);
                if(targetNode == null) {
                    continue;
                }
                if(root.isNodeDescendant(targetNode)) {  // returns root
                    return targetNode;
                }
            }
            return null;
        }
    
        private DefaultMutableTreeNode findNode(String s, JTree tree) {
            DefaultMutableTreeNode root =
                (DefaultMutableTreeNode)tree.getModel().getRoot();
            Enumeration e = root.breadthFirstEnumeration();
            while(e.hasMoreElements()) {
                DefaultMutableTreeNode node =
                    (DefaultMutableTreeNode)e.nextElement();
                if(node.toString().equals(s)) {
                    return node;
                }
            }
            return null;
        }
    
        private DefaultMutableTreeNode buildNode(int index, TreePath path) {
            int numNodes = path.getPathCount();
            DefaultMutableTreeNode node = null;
            DefaultMutableTreeNode lastNode = null;
            for(int i = index; i < numNodes; i++) {
                Object o = path.getPathComponent(i);
                String s = ((DefaultMutableTreeNode)o).toString();
                if(i == index) {
                    node = new DefaultMutableTreeNode(s);
                    lastNode = node;
                } else {
                    DefaultMutableTreeNode n = new DefaultMutableTreeNode(s);
                    lastNode.add(n);
                    lastNode = n;
                }
            }
            return node;
        }
    
        private void expand(JTree tree, TreePath path) {
            TreeNode node = (TreeNode)path.getLastPathComponent();
            if (node.getChildCount() > 0) {
                Enumeration e = node.children();
                while(e.hasMoreElements()) {
                    TreeNode n = (TreeNode)e.nextElement();
                    expand(tree, path.pathByAddingChild(n));
                }
            }
            tree.expandPath(path);
        }
    
        private JScrollPane getCenterComponent() {
            int[][] keys = { { 1, 3 }, {  }, { 2 } };
            left = new JTree(new DefaultTreeModel(getRoot(keys)));
            expandTree(left);
            keys = new int[][] { { 0, 2, 4 }, { 1 } };
            right = new JTree(new DefaultTreeModel(getRoot(keys)));
            expandTree(right);
            JPanel panel = new JPanel(new GridLayout(1,0));
            panel.add(new JScrollPane(left));
            panel.add(new JScrollPane(right));
            return new JScrollPane(panel);
        }
    
        private DefaultMutableTreeNode getRoot(int[][] keys) {
            DefaultMutableTreeNode root =
                new DefaultMutableTreeNode("root");
            DefaultMutableTreeNode[] nodes =
                new DefaultMutableTreeNode[keys.length];
            int n = 0;
            for(int i = 0; i < keys.length; i++) {
                n += keys[i].length;
            }
            DefaultMutableTreeNode[] subNodes = new DefaultMutableTreeNode[n];
            DefaultMutableTreeNode leaf;
            int subIndex = 0;
            for(int i = 0; i < nodes.length; i++) {
                nodes[i] = new DefaultMutableTreeNode(String.valueOf(i+1));
                root.insert(nodes[i], i);
                for(int j = 0; j < keys[i].length; j++, subIndex++) {
                    String s = String.valueOf(i+1) + (j+1);
                    subNodes[subIndex] =
                        new DefaultMutableTreeNode(s);
                    nodes[i].insert(subNodes[subIndex], j);
                    for(int k = 0; k < keys[i][j]; k++) {
                        s = String.valueOf(i+1) + (j+1) + (k+1);
                        leaf = new DefaultMutableTreeNode(s);
                        subNodes[subIndex].insert(leaf, k);
                    }
                }
            }
            return root;
        }
    
        private void expandTree(JTree tree) {
            DefaultMutableTreeNode root =
                (DefaultMutableTreeNode)tree.getModel().getRoot();
            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 JPanel getLastComponent() {
            JButton button = new JButton("move");
            button.addActionListener(this);
            JPanel panel = new JPanel();
            panel.add(button);
            return panel;
        }
    
        public static void main(String[] args) {
            BuildingNodes test = new BuildingNodes();
            JFrame f = new JFrame();
            f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            f.add(test.getCenterComponent());
            f.add(test.getLastComponent(), "Last");
            f.setSize(500,400);
            f.setLocation(20,75);
            f.setVisible(true);
        }
    }

  3. #3
    Melki is offline Member
    Join Date
    Jun 2008
    Posts
    20
    Rep Power
    0

    Default

    Thank you very much for your code. I will get you back if I get any queries over this.

    Thank you.

Similar Threads

  1. How to construct checkbox in rtf document using iText?
    By soumyanil in forum Advanced Java
    Replies: 0
    Last Post: 07-28-2008, 11:05 AM
  2. Specify path
    By borgrodrick in forum Eclipse
    Replies: 1
    Last Post: 02-12-2008, 11:03 PM
  3. Replies: 3
    Last Post: 12-05-2007, 02:22 AM

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •