Discussion :

[Kewty]

Bonjour,
J'ai décidé de poster sur le forum, car après de nombreuses recherche je n'ai toujours pas trouver sur internet.
Je possède un JTree avec des choses dedans classé par ordre alphabétique. Je souhaiterais que lorsque je suis sur mon arbre et qu'avec mon clavier je tape sur la lettre "S" l'arbre me rapproche des premiers objets comprenant un "S".

J'espère avoir été assez claire sinon n'hésitez pas à me le faire remarquez.
Merci d'avance !

[ardard]

Salut Kewty,

tu devrais regarder du coté des entrées clavier.

Tu récupères la touche "pressée" et tu fais une recherche sur les noms des nœuds de ton arbre en fonction de cette lettre.

J'ai pas le nom des interfaces et compagnie en tête, mais tu devrais trouver assez facilement.

bien à toi.

[Kewty]

Salut Kewty,

tu devrais regarder du coté des entrées clavier.

Tu récupères la touche "pressée" et tu fais une recherche sur les noms des nœuds de ton arbre en fonction de cette lettre.

J'ai pas le nom des interfaces et compagnie en tête, mais tu devrais trouver assez facilement.

bien à toi.

Merci de ta réponse, je vais regarder et poster ma réponse si j'arrive à le faire

[Kewty]

De retour !
J'arrive à recupérer mon noeud en appuyant sur une touche du clavier comme ceci :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
            public void keyPressed(KeyEvent e) {
                String pressKeyboard = String.valueOf(e.getKeyChar());
                String myWord = null;
                ITreeNode myNode = null;
                try {
                    List<String> sourceList = deviceSource.getSourceList();
                    for (String source : sourceList) {
                        if (source.startsWith(pressKeyboard)) {
                            String[] split = source.split(ISourceDevice.DEFAULT_SEPARATOR);
                            myWord = split[0];
                            break;
                        }
                    }
                    if (myWord != null) {
                        ITreeNode rootNode = deviceTree.getRootNode();
                        if (rootNode != null) {
                            List<ITreeNode> children = rootNode.getChildren();
                            for (ITreeNode node : children) {
                                if (node.getName().equals(myWord)) {
                                    myNode = node;
                                    break;
                                }
                            }
			System.out.println("myNode = " + myNode); 
                        }
                    }
                } catch (SourceDeviceException e1) {
                    e1.printStackTrace();
                }
            }

Cependant maintenant que j'ai le ITreeNode, je vois pas comment faire pour rediriger et sélectionner automatiquement ce noeud. J'ai essayé avec la methode suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
TreePath path = new TreePath(myNode);
tree.setSelectionPath(path );
tree.scrollPathToVisible(path );

Mais ça fonctionne pas... Une idée ? Merci d'avance.

[joel.drigo]

Salut,

Il y a plusieurs choses à prendre en compte :

1. le TreePath doit "lister" tous les nœuds du chemin, pas seulement la feuille (il pourrait y avoir plusieurs branches avec la "même" feuille)
2. il y a déjà un comportement par défaut similaire à ce que tu as implémenté, seulement il ne descend pas dans les nœuds non ouverts. Il faut supprimer ce comportement sinon il va interférer.
3. Attention à toujours chercher après le "suivant" actuellement sélectionné, sinon on trouve forcément le courant s'il commence par la même lettre. A moins que tu ne veuilles chercher qu'à partir du "premier" (donc à partir de la racine).
4. penser à la casse (en général, on appuie sur une touche en minuscule, alors que la première lettre des textes de l'arbre est peut-être en majuscule

Exemple :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
public class JTreeSelectionExample {
 
	public static void main(String[] args) throws IOException {
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		JTree tree = new JTree(createTree());
		tree.setScrollsOnExpand(true);
		tree.setRootVisible(false);
		tree.setShowsRootHandles(true);
 
		for(KeyListener keyListener : tree.getKeyListeners()) {
			tree.removeKeyListener(keyListener);
		}
		tree.addKeyListener(createKeyListener(tree));
 
		frame.add(new JScrollPane(tree));
 
		frame.setSize(600, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	private static KeyListener createKeyListener(JTree tree) {
		return new KeyAdapter() {
 
			@Override
			public void keyPressed(KeyEvent e) {
 
				char c = e.getKeyChar();
 
				TreeNode node;
				TreePath current = tree.getSelectionPath();
				if( current==null ) {
					node = (TreeNode) tree.getModel().getRoot();
				}
				else {
					node = getNextSibling((TreeNode) current.getLastPathComponent());
					if ( node==null ) {
						node = (TreeNode) tree.getModel().getRoot();
					}
				}
 
				TreeNode nextNode = getNextNode(node, c);
				if( nextNode==null ) {
					nextNode = getNextNode((TreeNode)tree.getModel().getRoot(), c);
				}
				if( nextNode==null ) {
					return;
				}
 
				TreePath path = createTreePath(nextNode);
				tree.setSelectionPath(path);
				tree.scrollPathToVisible(path);
 
			}
 
			private TreePath createTreePath(TreeNode node) {
				Deque<TreeNode> stack = new ArrayDeque<>();
				while(node!=null) {
					stack.push(node);
					node=node.getParent();
				}
				return new TreePath(stack.toArray());
			}
 
			private TreeNode getNextSibling(TreeNode node) {
				TreeNode parent = node.getParent();
				while ( parent!=null ) {
					int index = parent.getIndex(node)+1;
					if ( index<parent.getChildCount() ) {
						return parent.getChildAt(index);
					}
					node = parent;
					parent = node.getParent();
				}
				return null;
			}
 
			private TreeNode getNextNode(TreeNode node, char c) {
				return getNextNode(node, c, true);
			}
 
			private TreeNode getNextNode(TreeNode node, char c, boolean nextSibling) {
 
				if ( match(node,c) ) {
					return node;
				}
				for(int i=0; i<node.getChildCount(); i++) {
					TreeNode child =  getNextNode(node.getChildAt(i), c, false);
					if (  child!=null ) {
						return child;
					}
				}
 
				if (nextSibling) {
					TreeNode parent = node.getParent();
					while ( parent!=null ) {
						int index = parent.getIndex(node)+1;
						for(int i=index; i<parent.getChildCount(); i++) {
							TreeNode child =  getNextNode(parent.getChildAt(i), c, false);
							if (  child!=null ) {
								return child;
							}
						}
						node = parent;
						parent = node.getParent();
					}
				}
 
				return null;
 
			}
 
			private boolean match(TreeNode node, char c) {
				String s = node.toString();
				return !s.isEmpty() && Character.toLowerCase(s.charAt(0))==Character.toLowerCase(c);
			}
 
		};
	}
 
	private static MutableTreeNode createTree() throws IOException {
 
		DefaultMutableTreeNode root = new DefaultMutableTreeNode("");
		createTree(root,FileSystemView.getFileSystemView().getHomeDirectory().toPath(),2);
		return root;
 
	}
 
	private static void createTree(DefaultMutableTreeNode parent, Path dir, int depth) throws IOException {
		StreamSupport.stream(Files.newDirectoryStream(dir).spliterator(),false)
				             .map(path-> createNode(path, depth))
				             .forEach(parent::add);
	}
 
	private static MutableTreeNode createNode(Path path, int depth) {
		FileNode node = new FileNode(path);
		if( depth>0 && Files.isDirectory(path) ) {
			try {
				createTree(node, path, depth-1);
			} catch (IOException e) {
				// ignore
			}
		}
		return node;
	}
 
 
	private static class FileNode extends DefaultMutableTreeNode {
 
		public FileNode(Path path) {
			super(path.getFileName());
		}
 
	}
 
}

[Kewty]

Parfait merci de m'avoir aider je m'en suis presque sortie ça devrais le faire