Mise-à-jour d'une ListView

Version imprimable

Bonsoir tout le monde,

je travaille depuis peu sur un petit projet qui comporte une ListView que je veux gérer librement c'est à dire effacer son contenu y mettre un autre et tout ça à l'intérieur de la ListView autrement dit, en s'appuyant sur le 'ChangeListener', le code exécute les opérations voulues (suppression,remplissage) mais il y exception "java.lang.IndexOutOfBoundsException" suite à l'appel de la méthode 'Clear' je pense, et je vous assure que j'ai bien cherché avant de venir ici, voici mon code :
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 public void ListenerList(){ /* ListV étant la ListView avec un paramètre <String> */ ListV.getSelectionModel().selectedIndexProperty().addListener(new ChangeListener<Number>() { @Override public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) { Update(new File(ListV.getItems().get((int)newValue))); } }); } private void Update(File f){ ListV.getItems().clear(); for(File path: f.listFiles()){ ListV.getItems().add(path.getAbsolutePath()); } }
Pour ce qui est de ma recherche j'ai juste trouvé la solution du 'runnable' qui m'intrigue, j'aimerais toutefois si possible comprendre la cause de cette Erreur.

Merci pour votre aide ! :P

10/09/2016, 22h43
bouye

A mon avis qui n'engage que moi, ce n'est probablement pas une bonne idée de vider la liste au changement d'indice, sachant que probablement après le sélection model de la liste va essayer de modifier l'objet actuellement sélectionné. En plus, comme tu n'as pas mis de flag particulier; ce code risque de se produire en cascade lorsque tu modifie la liste (la vider et la remplir changent aussi l'indice sélectionner actuel).
Donc oui avoir du code qui s'exécute plus tard (Platform.runLater()) semble être une bonne direction de départ mais il faudra aussi mettre des sémaphores.

Salut,

Merci pour ta réponse, pour le moment j'essaye d'écarter la solution du 'runLater()', dans ta réponse il y a un truc que j'ai pas compris, le (Flag), est ce que ça veut dire une condition qui détermine le fonctionnement d'un listener ? si c'est le cas je ne sais pas comment faire ça, un peu d'aide !

J'ai aussi pensé à supprimer le listener et en créer un nouveau à chaque changement de liste mais j'ai toujours la même erreur :
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 private void AddListener(){ CL.add(new ChangeListener<Number>() { @Override public void changed(ObservableValue<? extends Number> observable, Number oldValue, Number newValue) { /*Avoir l'index de l'item*/ /*Arrêter le listener*/ /*Effacer la liste et la mettre à jour*/ /*Relancer un nouveau Listener*/ } }); ListV.getSelectionModel().selectedIndexProperty().addListener(CL.get(0)); } private void RemoveListener(){ ListV.getSelectionModel().selectedIndexProperty().removeListener(CL.get(0)); CL.clear(); }
Merci pour votre réponse !

C'est pas bien dur pourtant ; un exemple très générique :

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
private boolean machinChoseIsEditing = false;
 
/**
  * Écouteur pour la saisie utilisateur.
 */
private ChangeListener<MachinChose> = (observable, oldValue, newValue) -> {
    if (machinChoseIsEditing) {
        return;
    }
    machinChoseIsEditing = true; 
    try {
        // Si jamais l’écouteur doit modifier la valeur, il n'y aura pas propagation vu qu'on a positionné le flag.
        [...]
    } finally { // On est jamais a l'abri d'une exception alors autant réinitialiser le flag correctement.
       machinChoseIsEditing = false;
    }
}
 
/**
 * Méthode invoquée par le code (quand un contrôleur reçoit une valeur provenant de son parent ou modele par exemple) :
 */
public void changeTheValueFromZeCode(final MachinChose o) {
    machinChoseIsEditing = true; 
    try {
        // Vu que le flag a été positionné, l’écouteur ne fera rien.
        [...]
    } finally { // Idem.
       machinChoseIsEditing = false;
    }
}

ça évite de voir faire des removeListener() suivit de addListener() a chaque fois que tu modifies via le code un contrôle qui est écouté pour savoir les valeurs saisies par l’utilisateur (clavier, souris, sélection, etc.).

Salut,

Merci pour ta réponse mais ça n'a rien changé (ou peut-être que j'ai mal interprété ton code), le problème persiste, voici une autre méthode que j'ai essayé mais qui a aussi échoué :

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
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
 
private void MonListener(){
 
 
    	 ChangeListener<Number> cl = ((observable, oldValue, newValue) -> {
 
    	    if (IsEdit) {
    	        return;
    	    }
    	    IsEdit = true;
    	    try {
 
                  Operation((int)newValue);
 
 
    	    } finally {
    	    	IsEdit = false;
    	    }
 
 
    	    });
 
 
         ListV.getSelectionModel().selectedIndexProperty().addListener(cl);
 
 
    }
 
 
 
    public void Operation(final int index) {
 
    	IsEdit = true;
 
        try {
 
 
        	Update(index);
 
 
 
        } finally {
 
        	IsEdit = false;
 
        }
    }
 
 
/* ////////////////////////////////////////////////////////////////////// */
 
 
private void Update(int indexer){
 
    	boolean IsFolder = false;
    	boolean Active = false;
 
    	PrevSize = contenu.size();
 
    	int LSize = 0;
    	ArrayList<String> NElements = new ArrayList<String>();
 
 
    	File f = new File(contenu.get(indexer));
 
    	if (f.isDirectory()){
 
    		IsFolder = true;
 
     	for(File path: f.listFiles()){
 
     		if (!path.isHidden()){
 
     			NElements.add(path.getAbsolutePath());
     		    LSize++;
 
     		}
 
 
     	}
 
     	Active = true;
 
    	}else{
 
    		System.out.println("Ce n'est pas un dossier !");
 
    	}
 
    	LSize = NElements.size();
 
    	if (IsFolder && Active){
 
    		for(int i = 0;i < LSize; i++){
 
    		   if(i>=contenu.size()){
 
    			contenu.add(NElements.get(i));
 
 
    		   }else{
 
    			contenu.set(i, NElements.get(i));
 
    		   }
 
 
    	    }
 
 
    		if(LSize < PrevSize){
 
       		   for(int i = LSize; i < PrevSize;i++){
 
       			 contenu.set(i, "");
 
       		   }
 
 
       	    }
 
    		  Clean();
 
 
    	   }else{
 
    		   System.out.println("La méthode n'est pas active !");
 
    	   }
 
     }
 
/* //////////////////////////////////////////////////////////////////// */
 
     private void Clean(){
 
    	 int x = 0;
 
    	 ArrayList<Integer> Empty = new ArrayList<Integer>();
 
    	 for(int i =0; i<contenu.size();i++){
 
    		 if(contenu.get(i).equals("")){
 
    			 Empty.add(i);
 
    		 }
 
    	 }
 
    	 if(Empty.size()> 0){
 
    		 contenu.remove(14);  /*ici j'ai visé seulement l'élément sélectionné*/
 
    	 }
 
     }

Ici j'ai remplacé les éléments précédents par de nouveau éléments et ceux en plus je les ai remplacés par un "" (vide) et j'ai ensuite essayé de supprimer les Cells vides, et là j'ai eu la même exception (IndexOutOfBoundsException).

Merci pour votre aide !

15/09/2016, 19h46
guatto

Re salut,

Problème résolu, et sans avoir à utiliser de runLater :P , c'est ma dernière méthode que j'ai perfectionnée pour effacer les éléments en fonction du changement qui se produit dans la ListView, j'explique pour ceux qui auront besoin de comprendre et qui ont le même souci :

Par exemple si on prend une liste avec 24 éléments son index est donc (from 0 to 23) donc si on veut effacer par exemple de l'index 20 jusqu'au 23 il faut:
-bien sûr commencer quelque part effacer l'index 20 (la liste va avoir 23 éléments et l'index : (from 0 to 22)
-c'est ici le vrai problème, la boucle qui va effacer doit être, elle aussi, mise à jour en fonction du changement de l'indexation de la liste et donc pour faire simple on ajoute une décrémentation à la fin de chaque tour (c'est un peu idiot comme problème mais ça m'a pris des jours pour me rendre compte) :P !

Merci encore "bouye" !