Loading Specific nodes of XML into a JTree

[Ajay Singh]

Hi all

i was executing the code(VSX.java) given in

http://forums.sun.com/thread.jspa?messageID=10184400

and giving the input file(testfile.xml) as

<Root>
<Take ID="8799">A
<key >1</key>
<key weight="0.2">2</key>
</Take>
<Take ID="8789">B
<key weight ="0.4">1</key>
<key weight="0.1">2</key>
<relevant weight="0.1">w2</relevant>
</Take>
<Take ID="8489">C
<key weight ="0.5">1</key>
<relevant weight="0.6">w2</relevant>
</Take>
<Donttake>D
<keys weight ="0.5">1</keys>
</Donttake>
</Root>


The code loads all the nodes of the xml into a JTree.Now i was modifying the code so as to display only specific nodes(ie only Take node)and also inside that specific node,a specific node(ie only relevant node).How can i modify the code.Please help

[Rob Spoor]

DefaultMutableTreeNode allows you to remove nodes. So instead of modifying that creation code you could just create the full tree and remove what you don't want. Once the XML is in TreeNode form you can iterate over it a lot better.

I myself prefer using a DOM model like JDOM. That gives you immediate control over the entire structure.

[Ajay Singh]

thanks Rob for the reply

Based on your suggestion ,i am now loading the Every node of xml into a JTree
and now i am removing the irrelevant nodes using the following code

model = (DefaultTreeModel)tree.getModel();
path = tree.getNextMatch("Donttake", 0, Position.Bias.Forward);
path1 = tree.getNextMatch("key", 0, Position.Bias.Forward);
System.out.println(path+"........"+path1);
mNode = (MutableTreeNode)path.getLastPathComponent();
// mNode1=(MutableTreeNode)path1.getLastPathComponent();
model.removeNodeFromParent(mNode);
// model.removeNodeFromParent(mNode1);

I am able to delete the Donttake node of the xml but when i try to delete the key child node .I am getting a null pointer exception.I commented out the lines as shown above and saw that path1 itself is null.Somebody Please help

[Rob Spoor]

Is the key node visible, or is it hidden?

If I were you I'd do the removal directly on the tree nodes, not through the tree:

void filterNodes(DefaultMutableTreeNode node)
{
    String name = (String)node.getUserObject();
    if ("Donttake".equals(name) || "key".equals(name))
    {
        node.removeFromParent();
        // the entire node is removed, so don't bother removing the children
    }
    else
    {
        for (Enumeration e = node.children(); e.hasMoreElements(); )
        {
            DefaultMutableTreeNode child = (DefaultMutableTreeNode)e.nextElement();
            filterNodes(child);
        }
    }
}

Now of course the "Donttake".equals(name) || "key".equals(name) part may change, so you might want to turn that into a new method:

boolean shouldFilter(DefaultMutableTreeNode node)
{
    String name = (String)node.getUserObject();
    return "Donttake".equals(name) || "key".equals(name);
}

This will make it easier for you to change the filter rules - just change that one method.

You may want to do this prior to creating the tree, or prior to setting the tree model, so you won't have to update your tree afterwards again.
[ August 13, 2008: Message edited by: Rob Prime ]

[Ajay Singh]

thanks rob,but since i am a newbie in swings Programming i am having issues as to where filterNodes function would be called, in the following code.I am not sure where the tree is being created.This code loads all the nodes of xml in JTree.

 
import javax.swing.*;
import javax.swing.text.Position;
import javax.swing.tree.*;
 
import java.awt.Dimension;
import java.io.*;
import java.util.Enumeration;
 
import org.xml.sax.*;
import org.xml.sax.helpers.*;
import javax.xml.parsers.*;
 
public class VSX
{
   public TreeModel parse(String filename) 
  {

    SAXParserFactory factory = SAXParserFactory.newInstance( );
    XMLTreeHandler handler = new XMLTreeHandler( );
    try 
    {
    
      SAXParser saxParser = factory.newSAXParser( );
      saxParser.parse( new File(filename), handler);
    }
    catch (Exception e) 
    {
      System.err.println("File Read Error: " + e);
      e.printStackTrace( );
      return new DefaultTreeModel(new DefaultMutableTreeNode("error"));
    }
 
    System.out.println("\n\n\nGoint to return the relevant tree model:-)");
    
    return new DefaultTreeModel(handler.getRoot( ));
  }
 
public static class XMLTreeHandler extends DefaultHandler 
{
    private DefaultMutableTreeNode root, currentNode;
    public DefaultMutableTreeNode getRoot( ) 
    {
      return root;
    }
 
    // SAX parser handler methods
   public void startElement(String namespaceURI, String lName, String qName,Attributes attrs) throws SAXException
   {
 
         String eName = lName; // Element name
    
             if ("".equals(eName))
         eName = qName;
             Tag t = new Tag(eName, attrs);
             DefaultMutableTreeNode newNode = new DefaultMutableTreeNode(t);
 
             if (currentNode == null) 
             {
              root = newNode;
              }
             else 
             {
         
              // Must not be the root node
              currentNode.add(newNode);
         }
              currentNode = newNode;
 
   }
public void endElement(String namespaceURI, String sName, String qName)  throws SAXException 
    {
      System.out.println("......End..."+currentNode);
      currentNode = (DefaultMutableTreeNode)currentNode.getParent( );
    }
 
 public void characters(char buf[], int offset, int len) throws SAXException
    { 
      String s = new String(buf, offset, len).trim( );
      ((Tag)currentNode.getUserObject( )).addData(s);
    }
  }
 public static class Tag 
  {
    private String name;
    private String data;
    private Attributes attr;
 
    public Tag(String n, Attributes a) { name = n; attr = a; }
 
    public String getName( ) { return name; }
    public Attributes getAttributes( ) { return attr; }
    public void setData(String d) { data = d; }
    public String getData( ) { return data; }
 
    public void addData(String d) 
    {
      if (data == null) {
        setData(d);
      }
      else {
        data += d;
      }
    }
 
    public String getAttributesAsString( )
    {
      StringBuffer buf = new StringBuffer(256);
      for (int i = 0; i < attr.getLength( ); i++) 
      {
        buf.append(attr.getQName(i));
        buf.append("=\"");
        buf.append(attr.getValue(i));
        buf.append("\"");
      }
      return buf.toString( );
    }
 
    public String toString( )
   {
      String a = getAttributesAsString( );
      return name + ":" + a + (data == null ? "":" ("+ data +")");
    }
  }
 
 
 
  public static void main(String args[])
  {
    JFrame frame = new JFrame("VSX Test");
    VSX parser = new VSX( ); 
    TreeModel tr = parser.parse("files/Category.xml");
    JTree tree = new JTree(tr);
    JScrollPane scrollPane = new JScrollPane(tree);
    tree.setPreferredSize(new Dimension(400,10000));
    frame.getContentPane( ).add(scrollPane);
    frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    frame.setSize(500,700);
    frame.setVisible(true);
  }
}

can you please help
[ August 13, 2008: Message edited by: Rob Prime ]

[Rob Spoor]

 
    System.out.println("\n\n\nGoint to return the relevant tree model:-)");
// here you've done the parsing, so filter now
    DefaultMutableTreeNode root = handler.getRoot();
    filterNodes(root);
    return new DefaultTreeModel(root);
  }

That's where I'd put it. The entire tree has just been built but it isn't used yet, so it's a great opportunity to filter out what you don't need.

[Ajay Singh]

thanks rob,you solved most of my headache:-)

one more thing that is to be noted is that node.removeFromParent(); removes alternate key child nodes ,not all the child nodes ,something else has to be put here instead of node.removeFromParent() so as to remove all the key child nodes

[Rob Spoor]

You can remove a node from its parent by calling remove(int) or remove(MutableTreeNode) on the parent.

void filterNodes(DefaultMutableTreeNode node)
{
    int childCount = node.getChildCount();
    for (int i = childCount - 1; i >= 0; i--)
    {
        DefaultMutableTreeNode child = (DefaultMutableTreeNode)node.getChildAt(i);
        if (shouldFilter(child))
        {
            node.remove(i);
        }
        else
        {
            filterNodes(child);
        }
    }
}

Notice how I iterate backwords; that's a quite common trick when removing elements. If you remove from the back, the indexes of the previous elements won't change.