Vector auf JTree

[PollerJava]

Hallo nochmal,

ich habe noch ein schwierigeres Problem und zwar habe ich jetzt meine XML- Datei in einen Vector eingelesen und jetzt möchte ich diese Struktur in einem JTree darstellen,
z.B.:

         <Element type="Allgemein"	  					id="0"     				name="0">  		  
		<varID type="Info" id="0">
			<State id="0">
				<version>			1.0			                        </version> 
				<titel>	                           JavaProgramm          		   </titel>
				<width>				 1074						</width>
             <height>			 840						</height>
				<xPos>				 0						  </xPos>
              <yPos>				 0		     				  </yPos>		
			</State>
		</varID>		
	</Element>

Der JTree sollte dann so aussehen:

Allgemein
   | 
   ------Info
           |
           -------version
           -------titel
           -------width
           -------height
           -------xPos
           -------yPos

Ist das irgendwie einfach zu realisieren (vector an JTree übergeben wäre mir am liebsten ) bzw. wie macht man das am Besten?

lg

 

[ARadauer]

ich würde mir mal ein TreeModel machen, dass ein TreeModel implementiert:http://java.sun.com/javase/6/docs/api/javax/swing/tree/TreeModel.html

vorher würde ich mir eine einfache Baumstruktur aufbauen, die dann das Model benutzt. Vielleicht gibt es da auch schon was vorgefertigtes.
Ein Vector is ja nur eine Liste, woher soll den dein Baum wissen, was wo drinnen ist.

Wie ließst du den dein XML File ein? JDom, Sax..?

 

[ARadauer]

so ungefähr würde ich einen knoten definieren

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;

public class XmlNode {
	
	private ArrayList<XmlNode> nodes;
	private String tagName;
	private Map<String, String> attribute;
	
		
	public void addNode(XmlNode node){
		if(nodes==null)
			nodes = new ArrayList<XmlNode>();
		nodes.add(node);
	}
	
	
	public int getNumNodes(){
		if(nodes==null)
			return 0;
		return nodes.size();
	}
	
	public XmlNode getNode(int i){
		if(nodes==null)
			return null;
		return nodes.get(i);
	}
	
	public String getTagName() {
		return tagName;
	}

	public void setTagName(String tagName) {
		this.tagName = tagName;
	}

	
	public void addAttribut(String key, String value){
		if(attribute == null)
			attribute = new HashMap<String, String>();
		attribute.put(key, value);
	}
	
	public Map<String, String> getAttribute(){
		return attribute;
	}	

}

dein model hat dann nur einen verweis auf den root Knoten.

 

[ARadauer]

würde dann ungefähr so aussehen:

import java.io.File;

import javax.swing.event.TreeModelListener;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;


public class MyTreeModel implements TreeModel{
	
	private XmlNode root;
	
	public void parseTree(File f){
		//mhn..... kann nicht so schwer sein
		//bzw leicht aber auch nicht ;-)
	}

	@Override
	public void addTreeModelListener(TreeModelListener l) {
	}

	@Override
	public Object getChild(Object parent, int index) {
		if (parent instanceof XmlNode) {
			XmlNode n = (XmlNode) parent;
			return n.getNode(index);			
		}
		return null;
	}

	@Override
	public int getChildCount(Object parent) {
		if (parent instanceof XmlNode) {
			XmlNode n = (XmlNode) parent;
			return n.getNumNodes();
		}
		return 0;
	}

	@Override
	public int getIndexOfChild(Object parent, Object child) {
		if (parent instanceof XmlNode) {
			XmlNode n = (XmlNode) parent;
			return n.indexOfNode((XmlNode)child);
		}
		return -1;
	}

	@Override
	public Object getRoot() {
		return root;
	}

	@Override
	public boolean isLeaf(Object node) {
		if (node instanceof XmlNode) {
			XmlNode n = (XmlNode) node;
			return (n.getNumNodes()==0);
		}
		return true;
	}

	@Override
	public void removeTreeModelListener(TreeModelListener l) {
		// TODO Auto-generated method stub
		
	}

	@Override
	public void valueForPathChanged(TreePath path, Object newValue) {
		// TODO Auto-generated method stub
		
	}
	

}

wobei ich gerade sehe, dass es ein interface TreeNode gibt, das könnte man sich auch ansehen. Vielleicht gits auch schon vorgefertigte Systeme um eine XML Datei in einen JTree anzuzeigen.

Aber so würd ich es ungefähr machen. Hab vor ungefähr einem Jahr mal Abteilungen mit Personen in ca 6 Ebenen verwallten müssen und da hab ich so was ähnliches verwendet.

 

[PollerJava]

So lese ich die XML- Datei ein:

SAXBuilder builder = new SAXBuilder();	
	doc = builder.build(xmlFile);
        root = doc.getRootElement();
...

Vielen Dank für Deine Antworten, werd in diese Richtung probieren,
lg

 

[ARadauer]

ich denk auf jedenfall, dass das die richtige richtung ist. Dein root ist ja sicher auch schon irgend ein Knoten, vielleicht gibts da eine Möglicheit dass du das direkt oder über einen Adapter an das Model übergibtst. Bzw einfach was drum herum programmieren, das dein root im Model verwendet werden kann.

 

[PollerJava]

Ich habs jetzt (auf die schnelle, da der Stress überhand nimmt) so gelöst (rekursiv), Das Beispiel liest direkt eine XML- Datei ein und stellt es am JTree dar,
vielleicht wirds ja mal benötigt von irgendwem:

import java.awt.BorderLayout;
import java.io.IOException;
import java.util.Arrays;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTree;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.w3c.dom.Document;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

public class XMLToJTreeParser extends JFrame {

	private JTree tree;
	private JScrollPane scrollPane;

	public XMLToJTreeParser() {
		DefaultMutableTreeNode root = initTreeRoot("KonfigComponents.xml");
		tree = new JTree(root);
	}

        public JTree getTree() {
            return tree;
        }
        
	private DefaultMutableTreeNode initTreeRoot(String file) {
		Document doc = null;
		try {
		    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
		    DocumentBuilder builder = factory.newDocumentBuilder();
		    doc = builder.parse(this.getClass().getResourceAsStream(file));
		} catch (ParserConfigurationException e) {
			e.printStackTrace();
		} catch (SAXException e) {
			e.printStackTrace();
		} catch (IOException e) {
			e.printStackTrace();
		}
		if (doc == null)
		   return new DefaultMutableTreeNode("EMPTY");
		Node rootNode = doc.getFirstChild();
		DefaultMutableTreeNode root = new DefaultMutableTreeNode(rootNode.getNodeName());
		treeWalk(rootNode, 0, root);
		return root;
	}

	public static void treeWalk(Node node, int level, DefaultMutableTreeNode parentNode) {
		String nodeName = node.getNodeName();
		DefaultMutableTreeNode childNode = null;
		if (node.hasChildNodes()) {
                    level++;
                    NodeList list = node.getChildNodes();
                    int len = list.getLength();
                    for (int i = 0; i < len; i++) {
                            Node child = list.item(i);
                            childNode = new DefaultMutableTreeNode(child.getNodeName());
                            parentNode.add(childNode);
                            treeWalk(list.item(i), level, childNode);
                   }
		} 
                else {
		     childNode = new DefaultMutableTreeNode(node.getNodeValue());
		     parentNode.add(childNode);
		}
	}

	public final static StringBuffer repeat(int n, char c) {
		char[] cA = new char[n];
		Arrays.fill(cA, c);
		return (StringBuffer) new StringBuffer().insert(0, cA);
	}
}