Discussion :

[dev RC0]

Bonjour à tous,

Mon problème concerne les JTables et plus précisément la gestion des lignes.
J’ai déjà parcouru plusieurs TUTOS et lu pas mal de POSTS mais rien ne répond vraiment à ma question.

Et je veux surtout comprendre ce que je fais et non pas copier coller bêtement du code que je trouve.
Par exemple, les Renderer qui ont des méthodes qui prennent des paramètres, Quels sont-ils, pourquoi ce type de paramètre, à quoi correspond-t-il ?? J’ai besoin de comprendre ça de façon fonctionnelle.

Je vais donc tâcher d’expliquer le plus clairement possible ce dont j’ai besoin.

MON PROBLEME :

Je manipule des objets et j’ai besoin d’afficher à l’utilisateur certains de leurs attributs.
J’ai donc un JTable et un Modèle auquel je passe une Liste d’ objets.
Mon JTable et son Modèle fonctionnent déjà et j’affiche bien les données que je veux à la bonne place.
Mes objets ont des états, et en fonction de leur état, TOUTE la ligne du JTable qui affiche leurs données doit être d’une couleur ou d’une autre. (Couleur de fond ET couleur du texte)
Pour l’exemple, vert très clair en fond et vert foncé pour le texte, etc.…
Pareil pour chaque couleur. (Vert, Rouge, Jaune et Noir)
Si l’état de l’objet change, alors les couleurs de la ligne changent.

Voilà la fonction à mettre en place et je suis vraiment bloqué là.

Encore une fois j’ai besoin d’échanger et de comprendre quels concepts il faut adopter et pourquoi on utilise telle ou telle classe.


Merci à celles et ceux sauront éclairer ma lanterne..

[awane]

Hello dev RC0,

Je pense qu'il faut être encore un peu plus clair en expliquant bien ton problème.

Ici quand tu dis :

Par exemple, les Renderer qui ont des méthodes qui prennent des paramètres, Quels sont-ils, pourquoi ce type de paramètre, à quoi correspond-t-il ?? J’ai besoin de comprendre ça de façon fonctionnelle.

Tu parles des méthodes dans une classe Renderer et tu veux comprendre l'utilité de ces méthodes?

Si c'est le cas, il faut commencer par faire des simples tutos sur les Renderer et les Editors. Ensuite, on pourrait t'aider si tu as un problème dans le code.

Ici le tuto de sun : http://docs.oracle.com/javase/tutori...nts/table.html
Je pense que c'est n tutos complet sur l'utilisation des JTables avec les Rendrers, les Editors, les Filters....

Awane

[dev RC0]

Bonjour,

De retour de déplacement je prends connaissance de la réponse qui m'a été faite.
Merci donc a toi AWANE d'avoir prit 5 minutes pour me répondre.
J'en suis donc au même point.
J' avais déjà lu le tuto de sun mais je ne suis malheureusement pas bilingue et je ne dois donc pas comprendre toutes les finesses e ce tuto.

Toujours autant de questions:
Faut-il un renderer par ligne? ou par cellule? ou 1 renderer pour tout le JTable?
Faut-il un renderer par evennement que l'on veut créer? (1 pour le changement de couleur de la ligne, un pour je ne sais quoi d'autre?)

C'est ce genre de mise en oeuvre que je ne comprends pas bien...

[joel.drigo]

Salut,

On a soit un renderer par type de données, qui peut être un renderer unique (pour le type de données java.lang.Object), soit un renderer spécifique par colonne.
Soit une combinaison des deux, comme par exemple, des renderers par type (les String comme ça, les java.util.Date comme ci...) , et des renderers pour certaines colonnes pour gérer des cas particuliers, comme par exemple, telle colonne en rouge).

Le principe global étant, pour afficher la donnée d'une cellule,
- on détermine le renderer pour la colonne contenant cette cellule
- s'il n'y en a pas, on détermine le renderer pour la classe de la donnée de cette colonne

Ensuite la méthode getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) étant invoquée sur la classe de TableCellRenderer déterminée, pour la ligne et la colonne, il te faut lire l'état de l'objet (l'argument value), indépendamment de la colonne, pour déterminer les couleurs, correspondant à cet état, pour toute la ligne.

[dev RC0]

Merci Joël!

Du coup je n'ai pas encore tout bien compris, mais tu m'éclaire pas mal..
Je vois mieux la philosophie à appliquer, je vais donc pratiquer et étudier dans ce sens.

C'est drôle, j'ai bien conscience que tu as écris ça et ça doit tellement être évident pour toi, et moi ça fait 4 fois fois que je lis et je me dis:" Mais de quoi y m'parle là!!!???"...

Mais je vais bientôt tout piger comme toi!

Merci pour tes lumières.

Je laisse le post ouvert et le flaguerai à "résolu" quand je serai capable de l'expliquer à mon tour...

Bonne journée à tous.

[dev RC0]

Ou alors je vous propose un cas d'école. Rien ne vaut un exemple très concret pour comprendre une philo...

La base:
Imaginons un tableau qui affiche des tâches à faire.

Ce tableau contient un modele qui lui même contient une liste d'objets Taches.

Un objet Taches est constitué d'un numéro, d'un libéllé, d'une date de début et d'une date de fin.


Ce que l'on veut:

Clic droit sur la ligne d'une tache -> "Démarrer"
La ligne devient verte et un compteur se declenche.
Si la tache n'a pas été terminée avant sa date de fin, la ligne devient rouge.
Quand la tache est terminée, la ligne devient grise.


Petit exemple parlant.

En comprennant comment faire ça, j' appréhenderai mieux le concept du renderer et les objets à mettre en oeuvre..

[joel.drigo]

Salut,

Tu ajoutes une problématique là, à savoir, la mise à jour de l'affichage en temps réel, en fonction de l'état d'une tâche de fond

J'ai fait une tâche, non pas avec une date de début et de fin, mais avec une durée en secondes, parce que c'était plus facile pour faire une simulation (tu n'allais pas attendre 3 jours pour voir ta ligne se mettre en rouge ). J'ai ajouté un paramètre qui permet de simuler une tâche qui dure plus longtemps que prévu pour faire la simu.

Donc la classe de Tache :

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
public class Tache {
 
	private String nom;
	private int dureePrevue;
	private int vraieDuree;
	private volatile boolean started;
	private volatile long startTime;
	private volatile long elapsedTime;
 
	private ITaskListener taskRunningListener;
 
	/**
         * 
         * @param nom
         * @param dureePrevue la durée qu'on a prévu pour la tâche
         * @param vraieDuree la durée de simulation, pour avoir des tâches qui durent plus longtemps que prévu
         */
	public Tache(String nom, int dureePrevue, int vraieDuree) {
		this.nom = nom;
		this.dureePrevue = dureePrevue;
		this.vraieDuree = vraieDuree;
		this.started = false;
		this.startTime = -1;
		this.elapsedTime = -1;
	}
 
	public String getNom() {
		return nom;
	}
 
	// duree prévue
	public int getDureePrevue() {
		return dureePrevue;
	}
 
	// pour simuler des taches qui durent plus longtemps que prévu
	public int getVraiDuree() {
		return vraieDuree;
	}
 
	// tache démarrée et non terminée, donc en cours d'éxécution
	public boolean isStarted() {
		return started;
	}
 
	// vraie si tache exécutée au moins une fois (terminée ou pas)
	public boolean hasBeenRan() {
		return elapsedTime>=0;
	}
 
	// temps de demarrage de la dernière exécution
	public long getStartTime() {
		return startTime;
	}
 
	// temps écoulée depuis le début, pour la dernière exécution
	public long getElapsedTime() {
		return elapsedTime;
	}
 
	// démarrer la tache si pas en cours
	public void start() {
		if (!started) {
			Thread thread = new Thread() {
				@Override
				public void run() {
					started=true;
					startTime = System.currentTimeMillis();
					if ( taskRunningListener!=null) taskRunningListener.start(Tache.this);
					while( (elapsedTime = (System.currentTimeMillis() - startTime)/1000) <vraieDuree ) {
						yield();
						if ( taskRunningListener!=null) taskRunningListener.run(Tache.this, elapsedTime);
					}
					started=false; 
					if ( taskRunningListener!=null) taskRunningListener.finished(Tache.this);
				}
			};
			thread.start();
		}
	}
 
	// ecouteur pour mettre à jour le modèle en temps réel
	public void setTaskRunningListener(ITaskListener listener) {
		this.taskRunningListener=listener;
	}
 
}

Code :

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

1
2
3
4
5
6
7
8
9
10
// une interface pour mettre à jour l'affichage en fonction de l'évolution d'une tache
public interface ITaskListener {
 
	void start(Tache tache);
 
	void run(Tache tache, long elapsedTime);
 
	void finished(Tache tache);
 
}

Le modèle

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
import java.util.Vector;
 
import javax.swing.JTable;
import javax.swing.event.TableModelEvent;
import javax.swing.table.AbstractTableModel;
 
public class TacheTableModel extends AbstractTableModel {
 
	/**
         * 
         */
 
	private static final long serialVersionUID = 1L;
	private final static String[] TITLES = {"Nom","Duree (sec)","Etat","Temps écoulé depuis le début (sec)"};
	private Vector<Tache> tasks;
 
	/**
         * @param data les tâches initiales
         */
	public TacheTableModel(Vector<Tache> data) {
		this.tasks=data;
		ITaskListener taskListener = new ITaskListener() {
 
			@Override
			public void start(Tache tache) {
				updateModel(tache);
			}
 
			private void updateModel(Tache tache) {
				fireTableChanged(new TableModelEvent(TacheTableModel.this, tasks.indexOf(tache)));
			}
 
			@Override
			public void run(Tache tache, long elapsedTime) {
				updateModel(tache);
			}
 
			@Override
			public void finished(Tache tache) {
				updateModel(tache);
			}
		};
		for(Tache tache : data) {
			tache.setTaskRunningListener(taskListener);
		}
	}
 
	@Override
	public int getRowCount() {
		return tasks.size();
	}
 
	@Override
	public int getColumnCount() {
		return TITLES.length;
	}
 
	@Override
	public String getColumnName(int columnIndex) {
		return TITLES[columnIndex];
	}
 
	@Override
	public Class<?> getColumnClass(int columnIndex) {
		switch (columnIndex) {
		case 0:
			return String.class; 
		case 1:
			return Integer.class; 
		case 2:
			return String.class; 
		case 3:
			return Integer.class; 
		}
		return null;
	}
 
	@Override
	public Object getValueAt(int rowIndex, int columnIndex) {
		Tache tache = tasks.get(rowIndex);
		switch (columnIndex) {
		case 0:
			return tache.getNom(); 
		case 1:
			return tache.getDureePrevue(); 
		case 2:
			return getState(tache); 
		case 3:
			return afficheEllapsedTime(tache)?tache.getElapsedTime():null; 
		}
		return null;
	}
 
	// détermine le libellé de la colonne "état"
	private String getState(Tache tache) {
		if ( tache.isStarted() ) {
			if ( tache.getElapsedTime()>tache.getDureePrevue() ) {
				return "En cours (Retard)...";
			}
			else {
				return "En cours...";
			}
		}
		else if ( tache.hasBeenRan() ) {
			return "Exécutée";
		}
		return null;
	}
 
	// déterminer quand on affiche la colonne ellapsed
	private boolean afficheEllapsedTime(Tache tache) {
		// on affiche le temps écoulé depuis le début si la tache est démarré ou si la tache a été exécutée en durant plus longtemps que prévue
		return tache.isStarted()||tache.hasBeenRan()&&tache.getElapsedTime()>tache.getDureePrevue();
	}
 
	public Tache getTache(int rowIndex) {
		return tasks.get(rowIndex);
	} 
 
	public static Tache getTask(JTable jtable, int rowIndex) {
		return ((TacheTableModel)jtable.getModel()).getTache(rowIndex);
	}
 
}

Le renderer

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
import java.awt.Color;
import java.awt.Component;
 
import javax.swing.JTable;
import javax.swing.table.DefaultTableCellRenderer;
 
public class TacheRenderer extends DefaultTableCellRenderer {
 
	private static final long serialVersionUID = 1L;
 
	public TacheRenderer() {
	}
 
	@Override
	public Component getTableCellRendererComponent(JTable table, Object value,
			boolean isSelected, boolean hasFocus, int row, int column) {
 
		Tache tache = TacheTableModel.getTask(table, row);
 
		Component component = super.getTableCellRendererComponent(table, value,
                 isSelected, hasFocus, row, column);
 
		Color bgColor = null;
 
		if ( tache.getElapsedTime()>tache.getDureePrevue() ) {
			// a duré trop longtemps
			bgColor = Color.RED;
		}
		else if ( tache.isStarted() ) {
		// else if ( tache.hasBeenRan()() ) { // pour afficher en vert si tache exécutée au moins une fois, même si arrêtée
			bgColor = Color.GREEN;
		}
 
		Color fgColor;
		if ( bgColor!=null ) {
			if ( isSelected  ) {
				// pour différencier les lignes sélectionnées
				bgColor = bgColor.darker();
			}
			fgColor = Color.WHITE;
		}
		else {
			// couleur standard  on est obligé de faire ça avec le DefaultTableCellRenderer, qui mémorise les couleurs appliquées
			if ( isSelected  ) {
				bgColor = table.getSelectionBackground();
				fgColor =  table.getSelectionForeground();
			}
			else {
				bgColor = table.getBackground();
				fgColor =  table.getForeground();
			}
		}
 
 
		component.setForeground(fgColor);
		component.setBackground(bgColor);
 
 
		return component;
 
	}
 
}

Pour exécuter :

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
import java.awt.BorderLayout;
import java.awt.Point;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.util.Vector;
 
import javax.swing.JFrame;
import javax.swing.JMenuItem;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;
import javax.swing.table.TableCellRenderer;
 
public class Demo {
 
	public static void main(String[] args) {
 
		JFrame frame = new JFrame("Exemple");
 
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		JPanel panel = new JPanel();
		frame.getContentPane().add(panel);
		panel.setLayout(new BorderLayout());
 
		final JTable jtable = new JTable(new TacheTableModel(createData()));
 
		jtable.createDefaultColumnsFromModel();
		jtable.getColumnModel().getColumn(0).setPreferredWidth(70);
		jtable.getColumnModel().getColumn(1).setPreferredWidth(50);
		jtable.getColumnModel().getColumn(2).setPreferredWidth(100);
		jtable.getColumnModel().getColumn(3).setPreferredWidth(150);
 
		jtable.setShowGrid(false);
 
		jtable.setFillsViewportHeight(true);
 
		panel.add(jtable.getTableHeader(), BorderLayout.NORTH);
 
		jtable.getSelectionModel().setSelectionMode(
				ListSelectionModel.SINGLE_SELECTION);
 
		// nécessaire pour sélectionner une ligne sur popup
		jtable.addMouseListener(new MouseAdapter() {
 
			@Override
			public void mousePressed(MouseEvent event) {
				// selects the row at which point the mouse is clicked
				Point point = event.getPoint();
				int currentRow = jtable.rowAtPoint(point);
				jtable.setRowSelectionInterval(currentRow, currentRow);
			}
		});
 
		jtable.setComponentPopupMenu(createMenu(jtable));
 
                // on met le renderer sur les colonnes (la même instance ici)
		TableCellRenderer renderer = new TacheRenderer();
		for(int i=0; i<jtable.getColumnCount(); i++) {
	   	jtable.getColumnModel().getColumn(i).setCellRenderer(renderer);
		}
 
 
		JScrollPane scrollpane = new JScrollPane(jtable);
		panel.add(scrollpane, BorderLayout.CENTER);
 
		frame.getContentPane().add(panel);
 
		frame.setSize(600, 200);
		//frame.pack();
 
		frame.setLocationRelativeTo(null);
 
		frame.setVisible(true);
 
	}
 
	private static JPopupMenu createMenu(final JTable jtable) {
		JPopupMenu menu = new JPopupMenu();
 
		final JMenuItem menuItem = new JMenuItem("Démmarrer");
 
		menu.addPopupMenuListener(new PopupMenuListener() {
 
			@Override
			public void popupMenuWillBecomeVisible(PopupMenuEvent e) { 
				Tache tache = getSelectedTask(jtable);
				menuItem.setEnabled(!tache.isStarted());
			}
 
			@Override
			public void popupMenuWillBecomeInvisible(PopupMenuEvent e) {  
			}
 
			@Override
			public void popupMenuCanceled(PopupMenuEvent e) { 
			}
		});
 
		menuItem.addActionListener(new ActionListener() {
 
			@Override
			public void actionPerformed(ActionEvent e) {
				final Tache tache = getSelectedTask(jtable); 
				tache.start();
			}
		});
 
		menu.add(menuItem);
		return menu;
	}
 
	protected static Tache getSelectedTask(JTable jtable) {
		int selectedRow = jtable.getSelectedRow();
		if ( selectedRow<0 ) return null;
		return TacheTableModel.getTask(jtable, selectedRow);
	}
 
	private static Vector<Tache> createData() {
		Vector<Tache> taches = new Vector<>();
 
		taches.add(new Tache("Tache 1", 10, 10));
		taches.add(new Tache("Tache 2", 10, 20)); // tache qui durera plus longtemps que prévu
		taches.add(new Tache("Tache 3", 10, 10));
		return taches;
	}
 
}

[dev RC0]

Rhooo Ben alors là!!! Noël avant l'heure !!!

Merci! Je suis au taf à me prendre la tête sur SVN là (Galère galère) , mais je me plonge sur ton exemple dès ce demain (Petit réveillon oblige)...

Et bien joué! en effet c'est mieux de ne pas attendre 3 jours pour un changement de couleur !!!

Je mets à jour le post dès que j'ai appris, tester et compris l'exemple!!

Joyeux Noël à toi Joël, j'espère que tu vas réveillonner comme il se doit..
Merci encore.