Discussion :

[jctransler]

Bonjour à tous et à toutes.

J'ai un souci sur mon JTree.

J'appelle le insertNodeInto du DefaulTreeModel et mon noeud est bien ajouté à l'arbre mais il se place à la fin et non à l'indice indiqué.
Pourtant le getIndexOfChild me renvoie bien la bonne valeur, je suis un peu perdu.

D'avance merci ^^

[joel.drigo]

Salut,

Donne-nous tout le code d'insertion, avec en particulier la valeur d'index et comment tu la détermine, sans quoi difficile de te réponde.

Voici un POC qui fonctionne, si ça peut t'aider :

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
public class JTreeDemo {
 
	private final static AtomicInteger IDFACTORY = new AtomicInteger();
 
	public static void main(String[] args) {
 
		final JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		final DefaultMutableTreeNode root = new DefaultMutableTreeNode("ROOT");
		final DefaultTreeModel model = new DefaultTreeModel(root);
		final JTree jtree = new JTree(model);
 
		final JButton buttonAdd = new JButton("Add");
		final JButton buttonInsert = new JButton("Insert");
 
		frame.add( jtree );
		frame.add( buttonAdd, BorderLayout.NORTH);
		frame.add( buttonInsert, BorderLayout.SOUTH);
 
		buttonAdd.addActionListener(e-> add(jtree, model));
		buttonInsert.addActionListener(e-> insert(jtree, model));
 
		jtree.setSelectionPath(new TreePath(root));
 
		frame.setSize(300, 300);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
 
	}
 
	private static void add(JTree jtree, DefaultTreeModel model) {
		final TreePath selectedPath = jtree.getSelectionPath();
		final DefaultMutableTreeNode node = (DefaultMutableTreeNode)selectedPath.getLastPathComponent();
		final DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("NODE " + IDFACTORY.getAndIncrement());
		model.insertNodeInto(newNode, node, node.getChildCount());
		jtree.expandPath(new TreePath(node.getPath())); 
	}
 
	private static void insert(JTree jtree, DefaultTreeModel model) {
		final TreePath selectedPath = jtree.getSelectionPath();
		final DefaultMutableTreeNode node = (DefaultMutableTreeNode)selectedPath.getLastPathComponent();
		final DefaultMutableTreeNode parent = (DefaultMutableTreeNode)node.getParent();
		final DefaultMutableTreeNode newNode = new DefaultMutableTreeNode("NODE " + IDFACTORY.getAndIncrement());
		if ( node.getParent()!=null ) {
			model.insertNodeInto(newNode, parent, parent.getIndex(node));
		}
		else {
			JOptionPane.showMessageDialog(jtree, "Impossible d'insérer ici");
		}
	}
 
}

[jctransler]

Oula ça va pas être simple vu la tête de la classe le code utile est pas super centralisé :/

En gros, dans mon test j'ai un arbre avec une racine qui s'appelle "écrans" et dedans 5 feuilles.

Je fais ça :

Code :

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

m_TreeModel.insertNodeInto(newNode, parent, index);

m_TreeModel c'est bien le modèle de mon JTree, parent c'est bien le noeud "écrans", new Node c'est le noeud à ajouter qui est créé précédemment (je ne met pas le code parce-que c'est que des sous classes à nous) et index vaut 3.

si suite à cette appel je fais genre :

Code :

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

System.out.println(m_TreeModel.getIndexOfChild(parent,newNode));

ça me renvoie bien 3, mais mon noeud est en dernière position quand même.
Au début je pensais que c'était du à un code ultérieur, mais en mettant un breakpoint, j'ai bien vu que non, dès le insertNodeInto, c'est mal placé.
ça pourrait venir de l'instanciation de NewNode ?

[joel.drigo]

ça pourrait venir de l'instanciation de NewNode ?

Non, je ne pense pas, mais ça peut venir de l'implémentation de TreeNode. C'est une implémentation custom ou standard (genre DefaultMutableTreeNode) ?

[jctransler]

C'est du Custom qui hérite de DefaulMutableTreeNode.
Par contre ça implémente Comparable, ça peut venir de là, mais ça me parait bizarre quand même, spécifier explicitement un indice devrait suffire à outrepasser l'ordre du comparable non ?

[joel.drigo]

Et dans cette implémentation custom, insert() a été redéfinie ? On peut voir le code ? En quoi intervient le Comparable ? Si ça impose un ordre de tri des nodes dans leur parent, c'est normal que l'insertion à un index particulier n'a pas l'effet forcément d'insérer à cet endroit.

[jctransler]

Nom pas de redéfinition d'insert()

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
@SuppressWarnings("serial")
public class DMTNOrdered extends DefaultMutableTreeNode implements Comparable<DMTNOrdered>{
 
	public DMTNOrdered(Object user) {
		super(user);
	}
 
	protected Integer prefix = new Integer(-1);
 
	public Integer getPrefix() {
		return prefix;
	}
 
	public void setPrefix(int pP) {
		prefix = pP;
	}
 
	public static DMTNOrdered sort(DMTNOrdered node, boolean isRecursive) {
		//System.out.println("TRIE SUR LE NODE : " + node.getUserObject());
 
		ArrayList<DMTNOrdered> children = new ArrayList<DMTNOrdered>();
		//On parcours les enfants du node, avec recursivité
		//On ajoute les enfant à la List
		for(int i=0,c=node.getChildCount();i<c;i++) {
			DMTNOrdered child = (DMTNOrdered)node.getChildAt(i);
			if(child.getChildCount() > 0 && isRecursive) {
	            sort(child, true);
	        }
 
			children.add(child);
		}
 
		//Tri de la liste (utilisant le compareTo)
		Collections.sort(children);
 
		//On ajoute au node ses enfants
		for(int i=0,c=children.size();i<c;i++) {
			node.add(children.get(i));
		}
 
		return node;
	}
 
	@Override
	public int compareTo(DMTNOrdered o) {
		return getPrefix().compareTo(o.getPrefix());
	}
}

En gros on utilise un numéro caché (prefix) pour définir l'ordre ça vient surement de là sur coup. J'aurai pensé que le tri devait être explicitement appelé pour que ça ait une influence

[joel.drigo]

Normalement, il n'y a pas de tri implicite : tu es sûr que la méthode sort() n'est pas appelée quelque part (de manière évènementielle par exemple). Si tu décommentes la trace qu'il y a au début, on la voit ou pas lors de l'insertion...

[jctransler]

Non on ne la vois pas

[joel.drigo]

Et le modèle ? Custom ou DefaultTreeModel ?

[jctransler]

DefaultTreeModel

[joel.drigo]

Pas d'autres idées...

[jctransler]

Pas grave, merci quand même, j'ai gagné en compréhension ^^