Itération des noeuds finaux d'un treeviewer

Bonjour :)

Je voudrais créer un bouton qui me permette d'itérer à travers des noeuds finaux (n'ayant pas d'enfants donc) d'un treeviewer. Concrètement, si je n'ai pas sélectionné de noeud dans l'arbre, la sélection viendrait se placer sur le premier noeud final de l'arbre, puis sur le suivant, etc.

Si j'ai sélectionné un noeud dans l'arbre, la sélection viendrait se placer sur le noeud final suivant.

En fait, ce que je voudrais faire ressemble un peu à la fonction Next Change ou Next Difference dans la vue Team Synchronizing d'Eclipse.

La difficulté, c'est que je ne sais pas trop par où commencer l'algo.

Auriez-vous une idée?

Merci par avance :)

Salut,

Tout va dépendre du modèle que tu as passé à ton TreeViewer.
Si on prend comme exemple la classe suivante:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public class MyNode {
 
    /**
     * The children of sub-nodes.
     */
    private List < MyNode > children;
 
    /**
     * The parent node of this node.
     */
    private MyNode parent;
}

Un noeud a donc: un noeud père et une liste de noeuds enfants.
Sans sélection, pour récupérer la première feuille, il te faut faire:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
MyNode root = (MyNode) myTreeViewer.getInput();
MyNode firstLeaf = getFirstLeaf(root);
...
public MyNode getFirstLeaf(MyNode currentNode) {
    MyNode resultNode = null;
    // C'est une fonction récursive qui s'arrête quand elle a trouvé la première feuille.
    if (currentNode.isLeaf()) {
        resultNode = currentNode;
    } else {
        List < MyNode > children = currentNode.getChildren();
        if (children != null && !children.isEmpty()) {
            resultNode = getFirstLeaf(children.get(0));
        }
    }
    return resultNode;
}

Sinon, il te faut adapter l'algorithme pour qu'il récupère le premier noeud feuille à partir d'un noeud. Après, c'est de la théorie de graphe classique...

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
ISelection selection = myTreeViewer.getSelection();
if (selection instanceof IStructuredSelection) {
    MyNode selectedNode = (MyNode) ((IStructuredSelection) selection).getFirstElement();
    MyNode nextLeafNode = getNextLeaf(selectedNode);
}
...
public MyNode getNextLeaf(MyNode currentNode) {
    MyNode resultNode = null;
    if (!currentNode.isRoot()) {
        MyNode parentNode = currentNode.getParentNode();
        // Il faut regarder dans les frères du noeud courant, ou dans les frères de son père.
        // On cherche d'abord chez les frères:
        List < MyNode > children = parentNode.getChildren();
        if (children != null && !children.isEmpty()) {
            MyNode node;
            MyNode currentResult = null;
            int currentIndex = children.indexOf(currentNode);
            for (int i = currentIndex + 1; i < children.size() && currentResult == null; i++) {
                node = children.get(i);
                currentResult = getFirstLeaf(node);
            }
            if (currentResult != null) {
                resultNode = currentResult;
            } else {
                // On cherche chez les frères du père.
                resultNode = getNextLeaf(parentNode);
             }
        }
    }
    return resultNode;
}

Bon, tout ça n'est pas testé bien sur, c'est un algorithme "général"...
Je ne sais pas si ça va t'aider, mais c'est un début :mrgreen:

Voilà, à+
Gueritarish

Merci pour ton aide :)
Je vais déjà essayer d'avancer avec ça.