Rafraichissement pendant ajouts successifs

**Ynostel** · 24/06/2009, 15h00

Bonjour,

Je rencontre un souci lors du rafraichissement de ma JTable.

Dans mon projet, je parcours 1 ou plusieurs fichiers selon le choix de l'utilisateur puis j'ajoute une ligne à cette table à chaque fois qu'une ligne d'un fichier est parcourue.

Les lignes s'ajoutent sans problème au tableau par l'intermédiaire d'une arraylist mais je les vois seulement apparaître une fois que le parcours de tous les fichiers est terminé.

Je fais bien pourtant un fireTableRowsInserted(int firstRow, int lastRow) à chaque fois qu'une ligne est ajoutée.

J'ai construit mon propre model en redéfinissant notamment getValueAt(int row, int column) et getRowCount().
De ce fait dès que j'ajoute un objet à ma liste, une ligne s'ajoute automatiquement à la table.

Donc ma question est :

Pourquoi le rafraichissement ne s'effectue pas instantanément et comment résoudre ce problème ?

Merci.

**fr1man** · 24/06/2009, 15h06

Montre nous ton code.

**Ynostel** · 24/06/2009, 15h19

Table :

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
package org.playlisttransfermanager.ui.table;
 
import java.util.List;
 
import javax.swing.ListSelectionModel;
 
import org.playlisttransfermanager.entities.Track;
import org.apache.log4j.Logger;
import org.jdesktop.swingx.JXTable;
 
public class TracksListTable extends JXTable {
 
    private static final Logger log = Logger.getLogger(TracksListTable.class);
 
    private static final long serialVersionUID = -747275171625809839L;
 
    private final TracksListTableModel tableModel;
 
    public TracksListTable(List<Track> tracksList){
 
        super();
 
        this.setRowSelectionAllowed(true);
 
        this.setColumnControlVisible(true);
 
        this.setHorizontalScrollEnabled(true);
 
        this.getTableHeader().setReorderingAllowed(false);
 
        this.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
 
        this.setSortable(true);
 
        tableModel =
                new TracksListTableModel(
                        new Object[] { "", "Fichier", "Titre", "Artiste",
                                "Album", "Année", "Genre", "Durée", "Chemin" },
                        tracksList);
 
        this.setModel(tableModel);
 
        this.getColumn(0).setCellRenderer(
            this.getDefaultRenderer(Boolean.class));
        this.getColumn(0).setCellEditor(this.getDefaultEditor(Boolean.class));
    }
 
    public void addTrack(Track track){
 
        if (!this.isAlreadyExist(track)){
 
            log.debug("ADD TRACK TO TABLE : " + track);
 
            this.getTableModel().getTracksList().add(track);
        }
    }
 
    public Track getSelectedTrack(){
 
        if (this.getSelectedRow() != -1){
 
            return (Track) this.getValueAt(this.getSelectedRow(), 1);
 
        }
        else{
 
            return null;
        }
    }
 
    public TracksListTableModel getTableModel(){
 
        return tableModel;
    }
 
    public boolean isAlreadyExist(Track trackToFind){
 
        for (final Track track : this.getTableModel().getTracksList()){
 
            if (trackToFind.getAbsolutePath().equals(track.getAbsolutePath())){
 
                return true;
            }
        }
 
        return false;
    }
}

Model :

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
package org.playlisttransfermanager.ui.table;
 
import java.util.ArrayList;
import java.util.List;
 
import javax.swing.table.DefaultTableModel;
 
import org.playlisttransfermanager.PlaylistTransferManagerUtil;
import org.playlisttransfermanager.entities.Track;
import org.apache.log4j.Logger;
 
public class TracksListTableModel extends DefaultTableModel {
 
    private static final Logger log =
            Logger.getLogger(TracksListTableModel.class);
 
    private static final long serialVersionUID = 7909588994746430046L;
 
    private final List<Track> tracksList;
 
    public TracksListTableModel(Object[] columnIdentifiers,
            List<Track> tracksList){
 
        super();
 
        if (tracksList != null){
 
            this.tracksList = tracksList;
        }
        else{
 
            this.tracksList = new ArrayList<Track>();
        }
        this.setColumnIdentifiers(columnIdentifiers);
    }
 
    @Override
    public int getRowCount(){
 
        if (this.getTracksList() != null){
 
            log.debug("ROW COUNT : " + this.getTracksList().size());
 
            return this.getTracksList().size();
 
        }
 
        return 0;
    }
 
    /**
     * @return the tracksList
     */
    public List<Track> getTracksList(){
 
        return tracksList;
    }
 
    @Override
    public Object getValueAt(int row, int column){
 
        Object value = null;
 
        if (this.getTracksList() != null){
 
            final Track track = this.getTracksList().get(row);
 
            if (track != null){
 
                switch (column){
                    case 0:
                        value = track.isSelected();
                        break;
                    case 1:
                        value = track.getName();
                        break;
                    case 2:
                        value = track;
                        break;
                    case 3:
                        value = track.getArtist();
                        break;
                    case 4:
                        value = track.getAlbumTitle();
                        break;
                    case 5:
                        value = track.getYear();
                        break;
                    case 6:
                        value = track.getGenre();
                        break;
                    case 7:
                        value =
                                PlaylistTransferManagerUtil
                                        .getFormattedTrackLength(track
                                                .getLength());
                        break;
                    case 8:
                        value = track.getAbsolutePath();
                        break;
                    default:
                        value = "n/a";
                        break;
                }
            }
        }
 
        if (value == null){
 
            value = "n/a";
        }
 
        return value;
    }
 
    @Override
    public boolean isCellEditable(int row, int column){
 
        if (column == 0){
 
            return true;
        }
        else{
 
            return false;
        }
    }
 
    @Override
    public void setValueAt(Object value, int row, int column){
 
        if (this.getTracksList() != null){
 
            final Track track = this.getTracksList().get(row);
 
            if (track != null){
 
                if (value instanceof Boolean){
 
                    switch (column){
                        case 0:
                            track.setSelected(Boolean.parseBoolean(value
                                    .toString()));
 
                            this.fireTableCellUpdated(row, column);
                            break;
                        default:
                            value = "n/a";
                            break;
                    }
                }
            }
        }
    }
}

Classe Playlist (procédure appelée à chaque fois qu'une ligne est parcourue):

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
    public void addTrack(Track track){
 
        if (!this.isAlreadyExist(track)){
 
            this.getPropertyChangeSupport().firePropertyChange(
                DataEvent.ADDTRACK.toString(), null, track);
 
            log.debug("ADD TRACK TO PLAYLIST : " + track);
 
            this.getTracksList().add(track);
 
        }
    }

Classe principale :

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
@Override
    public void propertyChange(PropertyChangeEvent arg0){
 
        final String eventName = arg0.getPropertyName();
 
        log.debug("EVENTNAME : " + eventName);
 
        try{
 
            final DataEvent event = DataEvent.valueOf(eventName);
 
            switch (event){
 
                case ADDTRACK: {
 
                    final Track track = (Track) arg0.getNewValue();
 
                    this.getTracksListTable().addTrack(track);
 
                    this.getTracksListTable().getTableModel()
                            .fireTableRowsInserted(
                                this.getTracksListTable().getTableModel()
                                        .getTracksList().size() - 1,
                                this.getTracksListTable().getTableModel()
                                        .getTracksList().size() - 1);
 
                    return;
                }
            }
 
        }
        catch (final IllegalArgumentException e){
 
            log.debug(e.getMessage());
        }
    }

Voilà.

**adiGuba** · 24/06/2009, 15h25

Salut,

Où lis-tu le fichier ? Il faut impérativement faire cela dans une tâche de fond pour ne pas bloquer l'EDT !

De plus ton model est un peu bizarre : normalement tu devrais ajouter un éléments au modèle qui génèrerait un fireTableRowsInserted().
Toi tu ajoutes l'élément directement dans la liste et tu envoies toi même l'évenement

a++