Swing JTree ersten unterpunkt dauerhaft verstecken

[Enigma228]

ich habe einen JTree
Struktur:

Personen
+-> Name +Vorname
| +-> Index (soll dauerhaft versteckt werden)
| +-> E-Mail
+-> Name +Vorname
| +-> Index (soll dauerhaft versteckt werden)
| +-> E-Mail

... usw.

hat jemand ein Bsp. für mich wie ich sowas realisieren kann?
Es geht darum das ich den Eintrag bei Klick einwandfrei identifizieren kann aber der Nutzer muss ja nicht wissen, wie seine Indexnummer ist.

Vielen Dank
Thomas

 

[Michael...]

Wieso fügst Du dann die Indexnr ein, wenn sie nicht sichtbar sein soll? Die Indexnr kann ja ein Attribute des Objekts im Elternknoten sein.

 

[Enigma228]

Wie füge ich Attribute hinzu? hast du ein Beispiel?

 

[Michael...]

Was ich meinte ist, dass Du momentan vermutlich nur Strings in die Knoten des Trees einfügst. Du könntest aber auch Objekte einfügen ala:

class Nutzer {
	private index;
	public Nutzer(int index) {
		this.index = index;
	}
	
	public int getIndex() {
		return index;
	}
}

Wenn der Anwender dann ein Element selektiert (zB E-Mail) dann könnest Du den Vaterknoten nehmen nach Nutzer casten und dann auf dem gecasteten Objekt getIndex() aufrufen.

Oder Du könntest ein Interface mit dieser Methode verwenden, das alle Objekte im Tree implementieren müssen, dann kannst Du diese bei Selektion immer auf das Interface casten...

Ist in prosa etwas schwer zu beschreiben, hoffe der Gedanke dahinter ist verständlich.

 

[Enigma228]

Ein Objekt einfügen wäre der idealste Fall:

ich habe bereits eine Klasse Person mit den von dir beschriebenen Index.

ich kann ja auch ein Objekt einfügen soweit ich weiss aber die Darstellung im Baum ist dann nicht der Name + Vorname sondern die ObjektID
Wie schaffe ich es dass er es auch richtig anzeigt

meine Person Klasse:

package doc;

import java.util.ArrayList;

public class Person implements Comparable<Person>{
	
	private String index;
	private String name, firstname, street, streetnumber, city, postcode;
	private ArrayList<Msn> numbers= new ArrayList<Msn>();
	private ArrayList<Mail> mails= new ArrayList<Mail>();
	
	public Person() {
		name = "";
		firstname = "";
		street = "";
		streetnumber = "";
		city = "";
		postcode = "";
		index = "";
		
	}
		
	public Person(String index, String name, String firstname, String street,
			String streetnumber, String city, String postcode,
			ArrayList<Msn> numbers, ArrayList<Mail> mails) {
		super();
		this.index = index;
		this.name = name;
		this.firstname = firstname;
		this.street = street;
		this.streetnumber = streetnumber;
		this.city = city;
		this.postcode = postcode;
		this.numbers = numbers;
		this.mails = mails;
	}
	
	// Getter- und SetterMethoden
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getFirstname() {
		return firstname;
	}
	public void setFirstname(String firstnam) {
		this.firstname = firstnam;
	}
	public String getStreet() {
		return street;
	}
	public void setStreet(String street) {
		this.street = street;
	}
	public String getCity() {
		return city;
	}
	public void setCity(String city) {
		this.city = city;
	}
	public String getPostcode() {
		return postcode;
	}
	public void setPostcode(String postcode) {
		this.postcode = postcode;
	}
	public ArrayList<Msn> getNumbers() {
		return numbers;
	}
	public void setNumbers(ArrayList<Msn> arrayList) {
		this.numbers = arrayList;
	}
	public ArrayList<Mail> getMails() {
		return mails;
	}
	public void setMails(ArrayList<Mail> mails) {
		this.mails = mails;
	}
	
	public String getStreetnumber() {
		return streetnumber;
	}

	public void setStreetnumber(String streetnumber) {
		this.streetnumber = streetnumber;
	}


	public String getPerson(){
		String temp = new String();
		temp = "Name: "+getName()+"\nVorname: "+getFirstname()+"\n"+
			"Strasse: "+getStreet()+" "+getStreetnumber()+"\n"+
			"PLZ: "+getPostcode()+"\nOrt: "+getCity()+"\n\n";
		int n = numbers.size();
		for (int i=0;i<n;i++){
			temp = temp + numbers.get(i).getType()+" : "+numbers.get(i).getPrefix()+" "+
				numbers.get(i).getCallnumber()+" ("+numbers.get(i).getUsing()+")"+"\nInfo: "+numbers.get(i).getDescription()+"\n";
		}
		int m = mails.size();
		for (int i=0;i<m;i++){
			temp = temp + "\nMail: "+mails.get(i).getMail()+"\nInfo: "+mails.get(i).getDescription();
		}
		
		
		return temp;
	}

	public String getIndex() {
		return index;
	}

	public void setIndex(String index) {
		this.index = index;
	}
	
	// Überschreiben der Methoden damit Person in einer Treeset sortierbar sind 
	@Override
	public int compareTo(Person p) {
		if (name.compareToIgnoreCase(p.getName())==0){
			if(firstname.compareToIgnoreCase(p.getFirstname())==0){
				if(street.compareToIgnoreCase(p.getStreet())==0){
					if(streetnumber.compareToIgnoreCase(p.getStreetnumber())==0){
						if(city.compareToIgnoreCase(p.getCity())==0){
							return 0;
						}else{return city.compareToIgnoreCase(p.getCity());}
					}else{return streetnumber.compareToIgnoreCase(p.getStreetnumber());}
				}else{return street.compareToIgnoreCase(p.getStreet());}
			}else{return firstname.compareToIgnoreCase(p.getFirstname());}
		}else{return name.compareToIgnoreCase(p.getName());}
	}

	@Override
	public boolean equals(Object obj) {
		Person p = (Person)obj;
		return getIndex().equals(p.getIndex());
	}

	@Override
	public int hashCode() {
		return index.hashCode();
	}
	public boolean specialCompare(Person p){
		boolean marker = false;
		if(
				(getName().equalsIgnoreCase(p.getName()))
				&&(getFirstname().equalsIgnoreCase(p.getFirstname()))
				&&(getStreet().equalsIgnoreCase(p.getStreet()))
				&&(getStreetnumber().equalsIgnoreCase(p.getStreetnumber()))
				&&(getPostcode().equalsIgnoreCase(p.getPostcode())
				&&(getCity().equalsIgnoreCase(p.getCity())))
		){
			marker = true;
		}
		
		return marker;
		
	}
}

und das befüllen erfolgte bisher so im ActionListener:
Info:
t_listeningresults =>tabelle mit Suchergebnissen von dem die Person auf das JTree übertragen werden soll
root => root des Trees
dtrm_collection => Modell zum Tree

// Personen in die Liste übernehmen
if (arg0.getActionCommand().equals("addperson")){
	DefaultMutableTreeNode insertPerson = null;
	DefaultMutableTreeNode insertMail = null;
	// Abfrage ob Personen ausgewählt wurden
	for(int i=0; i<t_listeningresults.getRowCount(); i++){
		if((Boolean)t_listeningresults.getValueAt(i, 6)== true){
			for(Person p:myPersons){
				if(p.getIndex().equalsIgnoreCase((String)t_listeningresults.getValueAt(i, 0))){
					collectPersons.add(p);
					break;
				}
			}
		}
	}
	// gewählte Personen in JTree übertragen
	root.removeAllChildren();
	int i=1;
	for(Person p: collectPersons){
		insertPerson = new DefaultMutableTreeNode(i+"."+p.getName()+", "+p.getFirstname());
		i++;
		for (Mail m:p.getMails()){
			insertMail = new DefaultMutableTreeNode(m.getMail());
			insertPerson.add(insertMail);
		}
		root.add(insertPerson);
	}
	dtrm_collection.reload();
	t_listeningresults.clearSelection();
}

 

[Michael...]

Der einfachste Weg ist: Du überschreibst in der Klasse Person die toString() Methode, z.B:

public String toString() {
    return name + " " + firstname;
}

Die sauberste Möglichkeit ist: Du schreibst einen eigenen TreeCellRenderer, der dann den Knoten entsprechend darstellt.

 

[Enigma228]

habe eine Klasse erstellt aber welche Funktionen muss ich dafür überschreiben??? und wie?

package doc;

import javax.swing.tree.DefaultTreeCellRenderer;

public class CollectionTreeCellRenderer extends DefaultTreeCellRenderer {
	
}

oder sollte die Klasse nicht abgeleitet sondern das Interface implementieren?

 

[Michael...]

Mal von Deiner Klasse Person ausgehend und, dass Du DefaultMutableNodes im Tree verwendest, könnte der Renderer so aussehen:

class CustomTreeCellRenderer extends DefaultTreeCellRenderer {
	private CustomTreeCellRenderer renderComponent;
	private DefaultMutableTreeNode node;
	
	public Component getTreeCellRendererComponent(JTree tree, Object value, boolean sel, boolean expanded, boolean leaf, int row, boolean hasFocus) {
		renderComponent = (CustomTreeCellRenderer)super.getTreeCellRendererComponent(tree, value, sel, expanded, leaf, row, hasFocus);
		node = (DefaultMutableTreeNode) value;
		
		if (node.getUserObject() instanceof Person) {
			Person person = (Person)node.getUserObject();
			renderComponent.setText(person.getName() + ", " + person.getFirstName());
		}
		return renderComponent;
	}
}

 

[Enigma228]

Vielen Dank!!

ich habe mein Progamm entsprechend angepasst!!
Aber da ich bei dem ganzen auch noch lernen möchte, habe ich ein paar Fragen dazu:

also mit dieser Funktion hatte ich schon gerechnet, war mir aber nicht sicher.
habe ich das richtig verstanden:

private CustomTreeCellRenderer renderComponent;

damit erschaffst du ein JLabel (weil TreeCellRenderer ja eine Ableitung von JLabel ist) um eine Componente zurückgeben zu können

node = (DefaultMutableTreeNode) value;

also value ist also ein Knoten. ich dachte hier müsste ich schon auf eine Person casten.
Was wird bei dem Objekt value übergeben?? diese Funktion kann ja auch in der JTable überschrieben werden!
Kannst du hierzu nochmal etwas erläutern? ist das immer ein Knoten oder nur bei einer JTree? so ala Java swing für Dummies??
der Rest ist eindeutig..

DANKE nochmal!!

 

[Michael...]

private CustomTreeCellRenderer renderComponent;

damit erschaffst du ein JLabel (weil TreeCellRenderer ja eine Ableitung von JLabel ist) um eine Componente zurückgeben zu können

Korrekt <klugscheiss>Du meinst sicherlich DefaultTreeCellRenderer erbt von JLabel, TreeCellRenderer ist nur ein Interface</klugscheiss> Vermutlich könnte man auch ein JLabel verwenden und in Zeile 6 nach JLabel casten.

node = (DefaultMutableTreeNode) value;

also value ist also ein Knoten. ich dachte hier müsste ich schon auf eine Person casten.
Kannst du hierzu nochmal etwas erläutern? ist das immer ein Knoten oder nur bei einer JTree?

Im Falle von JTree ist es das "Knoten Objekt" da Du Deine Objekte zunächst in einen Knoten steckts und diesen in den JTree einfügst. Bei JList oder JTable e.g. fügst Du ja die Objekte direkt ein, hier könntest Du dann direkt auf Person casten.

 

[Enigma228]

Das war die Info die ich brauchte..

 

[Ebenius]

Am Rande: Schau Dir mal den Teil über CellRenderer an, im Sun Java™ Tutorial: How to Use Tables. Auch wenn es sich in dem speziellen Teil um eine JTable handelt und nicht um einen Baum; die Technik ist die gleiche. Das ganze findet sich dann bei Listen und Bäumen in gleicher Art wieder.

EDIT: Gibt auch einen Abschnitt über Bäume, auch dort gibt's was zu CellRenderers. Das Konzept ist bei dem JTable-Abschnitt aber besser erklärt. Trotzdem: Sun Java™ Tutorials: How to Use Trees

Ebenius

 

[Enigma228]

Danke für die Infos!!!