Swing Initialisierung des JTree

[XFlipX]

Hallo,

ich habe mal wieder ein Problem:

Und zwar, ich habe in meiner Applikation ein Panel in dem eine ScrollPane liegt in welcher wieder ein JTree liegt. Beim Start wird alles initialisiert und angezeigt. Zusätzlich habe ich eine Liste, die ich während der Laufzeit mit Dateien fülle. Über einen Doppelklick auf diese Dateien wird mir die interne Struktur der Datei im JTree angezeigt.

Das Problem ist jetzt, die Anfangsinitialisierung des JTree. Was ich meine: Beim Start / bei der Instanzierenug des JTree -> entweder ich weise dem JTree ein eigenes Model zu oder er nimmt das DefaultTreeModel. Ich bin also dazu verdammt im JTree schon im Vornherein was anzuzeigen, obwohl in meiner FileListe noch gar keine Dateien reingeladen wurden bzw. durch Doppelklick die Anweisung erfolgte, die Struktur der Datei im JTree zu visualisieren.

Wie könnte ich das lösen ?

Noch eine Frage:

Auf Doppleklick soll ja die Struktur-Visualisierung der Datei im Tree erfolgen. Ich habe das so gelöst, dass ich innerhalb der mouseClicked - Methode das Model für meinen JTree neu setze -> mit meinem eigenen Model + dateispezifischen Root-Node das ich vom Parser bekomme. Ist das eine saubere Lösung ? Also das ständige Neusetzen des Models.

Danke, XFlipX

 

[KrokoDiehl]

Wenn du ohnehin dein eigenes TreeModel hast, dann kannst du es doch dem JTree zu Beginn übergeben, auch wenn es leer ist.
Für die Aktualisierung müsste es schließlich auch genügen, wenn du "nur" die Wurzel jedes Mal neu setzt. Mit einem entsprechenden Ereignis wird der Baum dann ohnehin neu gezeichnet. Aber soweit ich das kenne ist das Neusetzen des Modells bei einer Tabelle "schlimmer" als beim Baum, von daher: Wenn du bisher mit dem Verhalten zufrieden bist, sehe ich auch keinen wirklichen Handlungsbedarf.

 

[XFlipX]

Das wäre ne Möglichkeit. Aber leeres TreeModel verstehe ich nicht. Mein TreeModel Konstruktor erwartet die Übergabe des WurzelKnotens vom Parser, den ich dann an den WurzelKnoten der Instanz vom TreeModel zuweise .

public SGTreeModel(SGNode root)
	{
		//Übergabe an das root der Instanz von SGTreeModel
		this.root = root;
	}

Müsste ich dann halt noch den StandardKonstruktor implementieren oder ?

Wie kann ich denn im Nachhinein die Wurzel meines Models neu setzen ? Muss ich dann das root auf public static setzen ?

Danke, XFlipX

 

[KrokoDiehl]

Wie kann ich denn im Nachhinein die Wurzel meines Models neu setzen ? Muss ich dann das root auf public static setzen ?

Aua!
Nein bitte nicht lieber über einen Setter machen. Hast du dein TreeModel von DefaultTreeModel geerbt? Wenn ja könnte dein Setter wie folgt aussehen:

public void setRoot(SGNode root)
{
    this.root = root;
    this.fireStructureChanged(
        this.root, 
        new Object[]{this.root},
        null,
        null);     
    // ok, bei den Parametern hier bin ich mir nicht so 100%ig sicher
}

Zu deinem anderen Problem: Ja du könnstest einen Standardkonstruktor hinzunehmen, oder

null

übergeben. Dann musst du natürlich im Modell sicherstellen, dass

null

-Zugriffe abgefangen werden. Ansonsten erstellst du einen Dummy-SGNode der z.B. nur "(Leer)" anzeigt. Sowas wie:

JTree myTree = new JTree( new SGTreeModel( new SGNode("(Leer)") ) );

 

[XFlipX]

Nein, mein TreeModel implementiert das TreeModel Interface.

XFlipX

 

[KrokoDiehl]

Dann musst du selbst so ein Ereignis auslösen. In dem Fall ist das wichtig, damit der JTree nämlich auf eine Änderung reagieren kann und automatisch z.B. ein

repaint()

macht.

 

[Ebenius]

Dann musst du selbst[...]

Damit meint KrokoDiehl, das selbst implementierte TreeModel muss das Ereignis selbst auslösen, wenn der Wurzelknoten ersetzt wurde. Nicht irgendwie "von außen"...

Ebenius

 

[KrokoDiehl]

Damit meint KrokoDiehl, das selbst implementierte TreeModel muss das Ereignis selbst auslösen, wenn der Wurzelknoten ersetzt wurde. Nicht irgendwie "von außen"...

Ebenius

:bae:

 

[XFlipX]

Hallo,

Konstruktor:

public SGTreeModel(SGNode root)
	{
		//Listener adden und Instanzieren einer eigenen Listener-Klasse
		this.addTreeModelListener(new MyTreeModelListener());
		
		//Übergabe an das root der Instanz von SGTreeModel
		this.root = root;
	}

und die innere Klasse implementiert das TreeModelListener Interafce womit ich wieder die 4 Methoden bekomme.

public class MyTreeModelListener implements TreeModelListener 
	{

		@Override
		public void treeNodesChanged(TreeModelEvent e){
			// TODO Auto-generated method stub
			
		}

		@Override
		public void treeNodesInserted(TreeModelEvent e){
			// TODO Auto-generated method stub
		}

		@Override
		public void treeNodesRemoved(TreeModelEvent e){
			// TODO Auto-generated method stub
			
		}

		@Override
		public void treeStructureChanged(TreeModelEvent e)
		{	
		}	
	}

Tja, hier habe ich erstmal nur -> die Reaktion auf ein Ereignis aber das Ereignis selber muss ja noch ausgelöst werden. Dazu brauche ich die fireStructureChanged Methode oder ?

XFlipX

 

[KrokoDiehl]

Oh, um Missverständnissen vorzubeugen:
Du implementierst TreeModel in deinem SGTreeModel, d.h. du musst auch die Methoden

void addTreeModelListener(TreeModelListener l);
void removeTreeModelListener(TreeModelListener l);

implementieren.
Dies bedeuted, dass du in deinem Modell irgendwie verwalten musst, welche (externen) Listener sich bei deinem Modell anmelden.

Wenn du nämlich einen JTree erstellst und ihm dein Modell gibst, dann hängt er sich als TreeModelListener daran und ruft die

add...

-Methode auf.
Wenn du in deinem Modell etwas änderst und diese Änderungen für die Außenwelt (zB den JTree) relevant sind, dann musst du dies den TreeModelListeners mitteilen, die bei deinem Modell lauschen.

Dazu kann ich mal folgende Quellen nennen:
Thread hier im Forum <-- eigener Thread von mir bzgl. EventListenerList und eigener Verwaltung
EventListenerList API

Generell sieht so etwas in Swing wie folgt aus:

public class MyBLAModel implements BLAModel
{
    protected transient EventListenerList listeners = new EventListenerList();
    
    @Override
    public void addBLAListener(BLAListener listener)
    {
        listeners.add(BLAListener.class, listener);
    }

    @Override
    public void removeBLAListener(BLAListener listener)
    {
        listeners.remove(BLAListener.class, listener);
    }

    //...

    protected void fireBLAEvent(BLAData data)
    {
        //vgl. obige Links
        Object[] blaListener = listeners.getListenerList();
        for (int i = blaListener.length-2; i >= 0; i -= 2)
        {
            if (blaListener[i] == BLAListener.class)
            {
                ((BLAListener)blaListener[i+1].blaHappend( new BLAEvent(data) );
            }
        }
    }

    // ...

    public void updateBLA(BLA bla)
    {
        // sonstwas im Modell anstellen

        // Änderungen nach außen mitteilen
        this.fireBLAEvent(blabla);
    }        
}

In deinem konkreten Fall müsstest du solch eine

fire

-Methode aufrufen, wenn du die Wurzel austauschst (bzw. generell irgendeinen Knoten änderst).

 

[XFlipX]

Hallo,

danke für die Ansätze, die ich leider noch nicht vollständig verstehe. Was übergibst du denn der fireBLAEvent -Methode für Daten ?

Und was bedeutet genau diese Zeile:

((BLAListener)blaListener[i+1].blaHappend( new BLAEvent(data) );

bzw. was macht oder sollte die blaHappend Methode machen ?

Änhlich die Update - Methode -> Was übergibst du dieser Methode an Daten

XFlipX

 

[KrokoDiehl]

Hm... mit dem "bla" wollte ich nur das gängige "foo" umgehen

Also das "bla" ist ein Platzhalter für den jeweiligen Listener-Typ. In deinem Fall also dem TreeModelListener.
Ein TreeModelListener hat - wie es dir die API bestimmt schon erklärt hat - einige Methoden. Eine davon ist die

void treeStructureChanged(TreeModelEvent e)

die du, meiner Ansicht nach, beim Neusetzen der Wurzel benachrichtigen solltest.
Konkret müsste die Methode bei dir dann etwa wie folgt aussehen:

protected void fireTreeStructureChanged( Object[] path )
{
    Object[] treeListener = listeners.getListenerList();
    // Code mit der for-Schleife
        ((TreeModelListener)treeListener[i+1]).treeStructureChanged(new TreeModelEvent(this, path));
        // "path" dürfte in dem Fall ein 'new Object[]{meineNeueWurzel}' sein
    //...        
}

Oder um es allgemein zu formulieren: Wenn du ein eigenes TreeModel implementierst, dann musst du auch die TreeModelListener verwalten können, die sich an dein Modell hängen. Ob du das über die gegebene Klasse EventListenerList oder über ein eigenes Array, oder eine ArrayList oder sonstwas machst, ist erst einmal egal.
Wenn nun in deinem Modell irgendwas verändert wird, oder dort etwas passiert, von dem die Listener (--> Zuhörer) mitbekommen sollten (z.B. weil sich der JTree neu zeichnen muss), dann muss du all die Listener, die sich zur Laufzeit via

addXXXListener()

an dein Modell gehängt haben, darüber benachrichtigen. Wie genau, das hängt vom jeweiligen Listener und der Art der Änderung ab. Wenn man sich die Methoden vom TreeModelListener mal anschaut, dann sagen deren Namen schon gut genug aus, wann man sie benachrichtigen sollte.

Viele Implementierungen in Swing haben dafür bereits Methoden, die alle mit

fireXXX()

benannt sind, wie z.B. das DefaultTreeModel, sodass es einfacher ist von solchen Klasse zu erben, da man sich um die Verwaltung von Listenern und das Auslösen von Events nur noch bedingt selbst kümmern muss.
Ansonsten muss man das natürlich selbst machen, so wie in deinem Fall. Wenn du nämlich die Wurzel im Modell einfach austauschst, und es dem JTree nicht sagst, dann macht der auch nichts. Und die Art und Weise, in der Swing derartiges handhabt ist über das Listener-Prinzip.

 

[XFlipX]

Nochmals danke für die Hilfe und die Gedult. Es funktioniert nun. Für mein erstes Problem habe ich mir ein DummyNode angelegt, was ich meinem Model übergebe. Das zweite Problem habe ich nun auch gelöst -> jetzt brauche ich nur noch den WurzelKnoten in meinem Model neu setzen.

Die nächsten Frage kommen bestimmt.

XFlipX