# Jtree zu langsam beim klappen



## _tiGGa_ (12. Okt 2006)

hallo,

ich hab ein problem
und zwar ^^

ich hab eine klasse, welche mir den gesamten jtree aufklappt bzw. zuklappt.
in meinem jtree habe ich unterschiedlich viele rows, mal 100 mal 1000, mall 5000

wenn ich 100 rows habe, geht es wunderbar schnell, 
sind es aber 1000, oder noch mehr brauch er ewig.

dabei muss ich sagen, ich hab mir einen eigenen renderer geschrieben, 
da ich verschiedene symbole für verschiedene zeilen haben möchte.
ich setze jedoch, bevor ich den jtree aufklappe den renderer auf null, und danach wieder auf meinen.
dies mache ich, da ich schon gemerkt hab, dass es schneller geht.

desweiteren sind die eigenschaften visible und enable bevor ich die methoden aufrufe auf false gesetzt.

kann man diesen code vielleicht noch verbessern?
bzw. kann man vielleicht auch mit dem modell arbeiten?

>1000 rows benötigt er > 3 min für das aufklappen, 
zum zuklappen ca. 30sec.

codeschnipsel:

```
public void aufklappen(JTree tree, boolean expand) {
      TreeCellRenderer temp_speicher = tree.getCellRenderer();
      tree.setCellRenderer(null);   	    	
      TreeNode root = (TreeNode)tree.getModel().getRoot(); 
       
        if (expand) {
            alle_aufklappen(tree);         
        } else {
           alle_zuklappen(tree);
        }               
       tree.setCellRenderer(temp_speicher);       
}

 public void alle_aufklappen(JTree tree) { 
        int row = 0; 
        
        while (row < tree.getRowCount()) {
          tree.expandRow(row);
          row++;
          }
} 
    
public void alle_zuklappen(JTree tree) { 
        int row = tree.getRowCount(); 
        while (row > 0) {
          tree.collapseRow(row);
          row--;
          }
}
```

danke und hoffe ihr könnt mir weiterhelfen 

greetz
_tiGGa_


----------



## AlArenal (12. Okt 2006)

```
// If expand is true, expands all nodes in the tree.
    // Otherwise, collapses all nodes in the tree.
    public void expandAll(JTree tree, boolean expand) {
        TreeNode root = (TreeNode)tree.getModel().getRoot();
    
        // Traverse tree from root
        expandAll(tree, new TreePath(root), expand);
    }
    private void expandAll(JTree tree, TreePath parent, boolean expand) {
        // Traverse children
        TreeNode node = (TreeNode)parent.getLastPathComponent();
        if (node.getChildCount() >= 0) {
            for (Enumeration e=node.children(); e.hasMoreElements(); ) {
                TreeNode n = (TreeNode)e.nextElement();
                TreePath path = parent.pathByAddingChild(n);
                expandAll(tree, path, expand);
            }
        }
    
        // Expansion or collapse must be done bottom-up
        if (expand) {
            tree.expandPath(parent);
        } else {
            tree.collapsePath(parent);
        }
    }
```

Was deinen Code angeht:


> Also note that performance wise, this probably has complexity O(n*n) (depending on the layout you are using for your tree).





> I prefer this code to collapse all nodes:
> 
> 
> ```
> ...



Selbst benutze ich weuder ne andere Variante.. da ich nun aber schnell zum Schnitzel-Essen muss, bin ich zu faul zum suchen.

Schönen Feierabend!


----------



## _tiGGa_ (13. Okt 2006)

hmm, also, die methoden mit der rekursion hatte ich auch schon benutzt, nur diese brauchen eine noch längere zeit.

zu der anderen methode fürs zuklappen, diese is ja eigentlich die gleiche wie meine, nur das es eine for-schleife is.

hab mir noch paar gedanken gemacht, ruft der jtree vielleicht eine interne repaint methode auf?
so dass er jedes element, welches aufgeklappt ist, gleich neuzeichnen möchte?

ich hab ja schon einen eigenen renderer geschrieben, doch vielleicht gibt es noch was anderes?

danke für eure hilfe

greetz
_tiGGa_


----------



## _tiGGa_ (13. Okt 2006)

sry, wegen dem doppelposting, doch manchmal spinnt die inetverbindung auf arbeit

hab noch bissel rumgetestet, aber irgendwie bringt es nix.

das höchste was vorkommen kann, sind knappe 100.000 zeilen im jtree ^^

nun hab ich mir überlegt, ich klappe nicht alles auf, sondern nur immer das, wass der user sieht + bissel toleranz
und sobald der user weiter scrollt, klappe ich wieder etwas auf, somit erscheint es, als ob alles aufgeklappt wäre.

nur wie geh ich da am besten ran?
mein jtree liegt in einem jscrollpane.

hab zur zeit garkeine idee.
bitte helft mir 

danke
_tiGGa_


----------



## AlArenal (14. Okt 2006)

Bei 100.000 Zeilen sollte man sich mal fragen, wer das denn noch sinnvoll bedienen können soll.


----------



## _tiGGa_ (15. Okt 2006)

hmmm, is aber leider so.
dies is ein projekt was eine xml-datei einlesen, die bestimmte daten enthält, welche später weiter verarbeitet wird.
und das jtree macht bestimmte fehler sichtbar, sodass man diese beheben kann, die anwender möchten allerdings auch mal die gesamte xml durchstöbern, deshalb muss ich das jtree aufklappen, und alle elemente sichtbar darstellen.

also, frag ich mich, ob dies auf einem weg umsetzbar is?


----------



## AlArenal (15. Okt 2006)

Ich sag mal so:
Keiner hat nen Bildschirm um 100.000 Zeilen anzuzeigen. Also könnte man ggf. auch das Aufklappen mit dem Scrollen des sichtbaren Bereichs synchronisieren. Nur so als Gedankenspiel.


----------



## _tiGGa_ (15. Okt 2006)

heheeee,

na das hab ich ja schon oben gepostet, nur such paar ansatzmöglichkeiten (s.o.) 

greetz
_tiGGa_


----------



## AlArenal (15. Okt 2006)

JTree liest aus naheliegenden Gründen nur die Daten aus dem Model,  die er zur Anzeige brauchst. Wenn du den kompletten Tree expanden willst, setzt das als Flag ins Model und sorge dafür, dass bei Zugriff auf einen Node geprüft wird, ob dieser im Tree sichtbar ist. Wenn ja, expandesst du alle seine Children (wenn vorhanden).


----------

