sélectionner une feuille à partir d'un String contenant le path

Version imprimable

Bonjour à tous !

J'ai une petite appli qui utilise beaucoup les JTree.
Je suis en train d'implémenter un système de sauvegarde en XML.

Mon problème est quand je charge un TreePath reconstruit à partir de la sauvegarde, à mon JTree, rien ne se passe :roll:

Voici un exemple qui illustre ce que je fais :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
 
import java.awt.BorderLayout;
 
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.tree.TreePath;
 
public class TestLoad extends javax.swing.JFrame {
 
	private JTree tree;
 
	public TestLoad() {
		super("test");
		tree = new JTree();
 
		 getContentPane().setLayout(new BorderLayout());
	     getContentPane().add(tree, BorderLayout.CENTER);
	     setSize(500,400);
 
	     DefaultMutableTreeNode[] s1 = new DefaultMutableTreeNode[3];
		s1[0] = new DefaultMutableTreeNode("JTree",true);
		s1[1] = new DefaultMutableTreeNode("colors",true);
		s1[2] = new DefaultMutableTreeNode("blue",false);
 
	     TreePath path = new TreePath(s1);
	     tree.setSelectionPath(path);	
 
	     tree.scrollPathToVisible(path);
 
	     if(tree.isPathSelected(path)) {
	    	 System.out.println("path selected");
	     }
	}
 
	public static void main(String[] args) {
		SwingUtilities.invokeLater(
	            new Runnable() {
	                public void run() {
	                	TestLoad test = new TestLoad();
	                	test.setVisible(true);
	                }
	            });
	}
}

ça me dit que le path est sélectionné, mais rien à l'affichage... vous avez une idée ?

Merci !

c'est parceque tu construit un path qui n'a aucun lien avec ton arbre. Il faut que tu utilises les noeuds de l'arbre et non tes propres noeuds que tu crée.

En theorie ils sont identiques mais ce ne sont pas les même objet : par exemple si tu essaye le code ci dessous cela devrait te selectionner et t'étendre la feuille blue :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
import java.awt.BorderLayout;
 
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
 
public class TestLoad extends javax.swing.JFrame {
 
    private JTree tree;
 
    public TestLoad() {
        super("test");
        tree = new JTree();
 
         getContentPane().setLayout(new BorderLayout());
         getContentPane().add(tree, BorderLayout.CENTER);
         setSize(500,400);
 
         DefaultMutableTreeNode[] s1 = new DefaultMutableTreeNode[3];
        s1[0] = new DefaultMutableTreeNode("JTree",true);
        s1[1] = new DefaultMutableTreeNode("colors",true);
        s1[2] = new DefaultMutableTreeNode("blue",false);
 
        TreeModel model = tree.getModel();
        DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
        DefaultMutableTreeNode colors = (DefaultMutableTreeNode) root.getFirstChild();
        DefaultMutableTreeNode blue = (DefaultMutableTreeNode) colors.getFirstChild();
         TreePath path = new TreePath(blue.getPath());
         tree.expandPath(path);
         tree.setSelectionPath(path);   
 
         tree.scrollPathToVisible(path);
 
         if(tree.isPathSelected(path)) {
             System.out.println("path selected");
         }
    }
 
    public static void main(String[] args) {
        SwingUtilities.invokeLater(
                new Runnable() {
                    public void run() {
                        TestLoad test = new TestLoad();
                        test.setVisible(true);
                    }
                });
    }
}

Donc a mon avis pas le choix pour toi il faut que tu parcours tous les fils que tu selectionnes le bon puis que tu parcours tout ces fils et que selectionne le bon et ainsi de suite....

tu as raison c'était ça...

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
package plotter.view.component.tree;
 
import java.awt.BorderLayout;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
import java.util.List;
 
import javax.swing.JFrame;
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeNode;
import javax.swing.tree.TreePath;
 
public class TestLoadTree extends javax.swing.JFrame {
 
	private JTree tree;
 
	public TreePath getPath(TreeNode node) {
	    List<TreeNode> list = new ArrayList<TreeNode>();
 
	    while (node != null) {
	      list.add(node);
	      node = node.getParent();
	    }
	    Collections.reverse(list);
 
	    return new TreePath(list.toArray());
	  }
 
	public TreePath findByName(JTree tree, String[] names) {
        TreeNode root = (TreeNode)tree.getModel().getRoot();
        return find(tree, new TreePath(root), names, 0, true);
    }
 
	private TreePath find(JTree tree, TreePath parent, Object[] nodes, int depth, boolean byName) {
        TreeNode node = (TreeNode)parent.getLastPathComponent();
        Object o = node;
 
        // If by name, convert node to a string
        if (byName) {
            o = o.toString();
        }
 
        // If equal, go down the branch
        if (o.equals(nodes[depth])) {
            // If at end, return match
            if (depth == nodes.length-1) {
                return parent;
            }
 
            // Traverse children
            if (node.getChildCount() >= 0) {
                for (Enumeration<TreeNode> e=node.children(); e.hasMoreElements(); ) {
                    TreeNode n = e.nextElement();
                    TreePath path = parent.pathByAddingChild(n);
                    TreePath result = find(tree, path, nodes, depth+1, byName);
                    // Found a match
                    if (result != null) {
                        return result;
                    }
                }
            }
        }
 
        // No match at this branch
        return null;
    }
 
	public TestLoadTree() {
		super("test");
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		tree = new JTree();
 
		getContentPane().setLayout(new BorderLayout());
		getContentPane().add(tree, BorderLayout.CENTER);
		setSize(500,400);
 
 
		TreePath path3 = findByName(tree,new String[]{"JTree", "food", "bananas"});
 
		 tree.getSelectionModel().setSelectionPath(path3);
 
		 tree.setExpandsSelectedPaths(true);
		 tree.scrollPathToVisible(path3);
		 tree.expandPath(path3);
 
 
		 if(tree.isPathSelected(path3)) {
			 System.out.println(tree.getSelectionPath());	 
		 }
	}
 
	public static void main(String[] args) {
		SwingUtilities.invokeLater(
	            new Runnable() {
	                public void run() {
	                	TestLoadTree test = new TestLoadTree();
	                	test.setVisible(true);
	                }
	            });
	}
}

22/06/2009, 09h06
Mathusalem

salut à tous !

J'y suis presque : dans l'exemple ci-dessus tout va bien, mais dans le cadre de mon appli c'est moyen : le classpath est correctement affecté, mais le JTree ne se rafraichi pas et ne sélectionne pas visuellement l'élément du classpath.

Pourtant j'ai bien fait un repaint() de l'arbre

Il y a sûrement quelque chose que j'ai manqué, vous avez une idée ?
22/06/2009, 09h28
el_filosof

As tu essayé de faire ta selection sur le jtree directement plutot que sur le model ?

Dans ton code ci dessus tu fait un : tree.getSelectionModel().setSelectionPath(path3)
essaye : tree.setSelectionPath(path3).

Si aussi tu dois selectionner plusieurs path utilise le tree.addSelectionPath(path3).

Verifie aussi que ton chemin est bien etendu jusqu a la feuille a afficher, il se peut que tu perde la selection en deployant ton arbre. Sinon pour plus d'aide envoie le bout de code qui devrait fonctionner je testerai sur ma machine.

merci de ta réponse.

et surtout pour l'info sur l'ajout de plusieurs paths, le prochain arbre est un checkboxTree :mrgreen:

Toutefois le getSelectionPath fonctionne pareil au niveau de l'arbre que du model : si j'interroge l'arbre je peux récupérer le path que je viens d'affecter, mais visuellement rien ne bouge
Code:

1 2 3 4 5 6 7 8 9 10 public void setVariableX(TreePath path) { jTreeFieldX.setExpandsSelectedPaths(true); //jTreeFieldX.getSelectionModel().setSelectionPath(path); jTreeFieldX.setSelectionPath(path); jTreeFieldX.scrollPathToVisible(path); jTreeFieldX.repaint(); System.out.println(jTreeFieldX.getSelectionPath()); }

Ta méthode fonctionne très bien chez moi je t'ai fait un petit exemple vite fait en repartant des codes ci dessus plus ta methode :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
 
import java.awt.BorderLayout;
import java.awt.Button;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JTree;
import javax.swing.SwingUtilities;
import javax.swing.tree.DefaultMutableTreeNode;
import javax.swing.tree.TreeModel;
import javax.swing.tree.TreePath;
 
public class TestLoad extends javax.swing.JFrame {
 
    private JTree tree;
    private boolean choix;
 
    public TestLoad() {
        super("test");
        this.tree = new JTree();
        this.choix=true;
 
         getContentPane().setLayout(new BorderLayout());
         getContentPane().add(tree, BorderLayout.CENTER);
         setSize(500,400);
         Button change = new Button("Change");
         getContentPane().add(change, BorderLayout.PAGE_END);
         change.addActionListener(new ActionListener(){
 
            public void actionPerformed(ActionEvent e) {
                switchSelect(choix);
                if (choix) {
                    choix =false ;
                } else {
                    choix =true;
                }
 
            }
 
         });
    }
 
    public void switchSelect(boolean choix) {
        TreeModel model = tree.getModel();
        TreePath path = null;
        if(choix) {
            DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
            DefaultMutableTreeNode colors = (DefaultMutableTreeNode) root.getFirstChild();
            DefaultMutableTreeNode blue = (DefaultMutableTreeNode) colors.getLastChild();
            path = new TreePath(blue.getPath());
        } else {
            DefaultMutableTreeNode root = (DefaultMutableTreeNode) model.getRoot();
            DefaultMutableTreeNode food = (DefaultMutableTreeNode) root.getLastChild();
            DefaultMutableTreeNode bananas = (DefaultMutableTreeNode) food.getLastChild();
            path = new TreePath(bananas.getPath());
        }
 
        setVariableX(path);
    }
 
    public void setVariableX(TreePath path) {
 
        tree.setExpandsSelectedPaths(true);
        //jTreeFieldX.getSelectionModel().setSelectionPath(path);
        tree.setSelectionPath(path);
        tree.scrollPathToVisible(path);
 
        //tree.repaint();
        System.out.println(tree.getSelectionPath());
    }
 
    public static void main(String[] args) {
        SwingUtilities.invokeLater(
                new Runnable() {
                    public void run() {
                        TestLoad test = new TestLoad();
                        test.setVisible(true);
                    }
                });
    }
}

si ce code fonctionne chez toi alors le problème ne viens pas du setselectionpath.. il faudra chercher ailleur...

22/06/2009, 16h31
Mathusalem

merci pour le code, ça marche aussi correctement chez moi, donc c'est pas ça...

je vais chercher, merci encore pour le coup de main