Discussion :

[zuzuu]

Salutation !

Je suis actuellement entrain de découvrir les merveilles que l'on peut faire avec des JTable.
Je en avoir un spécial qui permette d'ajouter des titres en column mais aussi en ligne et également un titre dans le coin supérieur gauche.
Aussi, j'ai compris comment utiliser un table model et le Jtable pour me bricoler le tout.
Cependant, voici mon problème. Car je m'y perd un peu.
Je voudrais pourvoir afficher le fond des lignes alternativement gris dégradé / gris foncé dégradé.
Mais je ne sais pas trop où partir. J'ai vu qu'il y avait une histoire de rendu de cellule mais je ne comprends pas vraiment comment faire?
Pourriez vous me guidez vers les outils adéquates à utiliser.
Merci d'avance et très bonne journée à vous !

[dinobogan]

Pour l'alternance de couleur, un début d'explication se trouve dans.... la javadoc
Le Renderer est appelé via une méthode qui contient en paramètre entre autre le numéro de ligne. Il suffit calculer si ce numéro est pair ou impair pour coloré en gris clair ou foncé.

[zuzuu]

En fait pour l'instant, j'ai l'impression qu'il y a peu être déjà un look and feel de défini qui fait cela.
J'ai déjà les couleurs de mes lignes corectement mise.
Cependant, je voudrais que la couleur soit dégradée...
Je vais regarder du coté du Renderer...

[bouye]

Pour faire que le fond soit degrade il faut :
- mettre le renderer en non-opaque.
- surcharger sa methode paintComponent() comme a l'habitude. Peindre un gradient qui recouvre toute sa surface puis appeler super.paintComponent() (alors que generalement on fait l'ordre inverse).

Sinon voir avec un JXLabel et un Painter a la place du DefaultTableCellRenderer habituel (aller voir ses sources dans src.zip pour piquer les methodes d'initialisation et de configuration du composant).

EDIT - correction.

[zuzuu]

J'ai trouvé quelque truc sur le net. Mais pour l'instant, c'est mon texte qui s'affichent en dégradé alors que je voudrais que ce soit le fond de mon label.
Snif :
Voici le code que j'utilise :

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
 
public class MyLayeredPanel extends JLabel {
 
        public void paint(Graphics g){
          Graphics2D g2d = (Graphics2D)g;
          Color s1 = Color.red;
          Color e = Color.green;
          GradientPaint gradient = new GradientPaint(10,10,s1,30,30,e,true);
          g2d.setPaint(gradient);
          g2d.drawRect(100,100,200,120);
          Color s2 = Color.yellow;
          Color e1 = Color.pink;
          GradientPaint gradient1 = new GradientPaint(10,10,s2,30,30,e1,true);
          g2d.setPaint(gradient1);
          g2d.fillRect(99,99,199,119);
 
          g2d.drawString(getText(), 0, getFont().getSize());
        }
 
 
}

[visiwi]

Salut,

Ne serait-ce pas :

Code :

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

1
2
3
4
5
6
7
8
public void paint(Graphics g){
          Graphics2D g2d = (Graphics2D)g;
          Color s2 = Color.yellow;
          Color e1 = Color.pink;
          GradientPaint gradient1 = new GradientPaint(10,10,s2,30,30,e1,true);
          g2d.setPaint(gradient1);
          g2d.fillRect(0,0,getWidth(),getHeight());
}

Cela fonctionnera avec un dégradé "bouclé" puisque tu dessine le dégradé cellule par cellule, mais si tu veux un dégradé qui s'exerce depuis le 0 jusqu'au bout de la table... cette méthode ne fonctionne plus.

[zuzuu]

Ah oui ! C'est bon j'ai compris comment m'en servir !
Merci beaucoup !

[zecreator]

Il faut éviter les appels de méthodes graphiques dans un renderer (comme paint, repaint...), ça bouffe de la CPU et de la RAM.

Ce n'est pas performant du tout...

Il vaut mieux travailler avec le paint de la JTable.

Zecreator.

[adiGuba]

Salut,


A noter que si l'on souhaite simplement une alternance des couleurs, il est possible d'utiliser le code suivant (qui impactera toutes les JTable tant qu'on utilise des DefaultCellRenderer) :

Code :

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

UIManager.put("Table.alternateRowColor", Color.GRAY);

Il faut éviter les appels de méthodes graphiques dans un renderer (comme paint, repaint...), ça bouffe de la CPU et de la RAM.

Ok pour les repaint() ou autre validate() qui sont complètement inutile vu l'affichage spécifique des cellules de la JTable, et d'ailleurs elles sont redéfinit avec un corps vide dans DefaultTableCellRenderer...

Par contre c'est bien paintComponent() qui est utilisé pour dessiner la cellule... mais pas de la manière habituelle (le composant n'est pas vraiment ajouté dans l'arborescence des composants, et il est réutilisé pour toutes les cellules).



D'ailleurs pour avoir un dégradé différent par ligne je ne vois pas d'autres solutions (sauf erreur le paintComponent() de la JTable doit permettre de faire un dégradé global mais pas ligne par ligne...).
La grosse difficulté vient du fait que le fond est dessiné cellule par cellule. Donc si on veut un dégradé cohérent sur toute la ligne il faut calculer les position par rapport à l'emplacement de la cellule dans la JTable.

Exemple :

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
class GradientTableCellRenderer extends DefaultTableCellRenderer {
 
	// Les deux couleurs principales des lignes :
	private final Color color1;
	private final Color color2;
 
	// A calculer pour chaque colonne :
	private int gradientX;		// L'origine en X du gradient
	private int gradientWidth;	// La taille du gradient
	private Color gradientColor;// La couleur du gradient pour la ligne courante
 
	public GradientTableCellRenderer(Color c1, Color c2) {
		setOpaque(false); // Car on va dessiner le fond nous même
		// Les couleurs de l'alternance des lignes :
		this.color1 = c1;
		this.color2 = c2;
	}
 
	@Override
	public Component getTableCellRendererComponent(JTable table, Object value,
			boolean isSelected, boolean hasFocus, int row, int column) {
		// On récupère les infos sur la position de la cellule :
		Rectangle rect = table.getCellRect(row, column, true);
		// On détermine la position en X du début du gradient par rapport à la cellule :
		this.gradientX = -rect.x;
		// On détermine la taille du gradient par rapport à la cellule :
		this.gradientWidth = table.getWidth()-rect.x;
		// On détermine la couleur du gradient par rapport à la ligne :
		this.gradientColor = row%2==0 ? this.color1 : this.color2;
 
		// On se contente d'appeler la méthode parente qui s'occupe de tout initialiser :
		return super.getTableCellRendererComponent(table, value, isSelected, hasFocus,
				row, column);
	}
 
	@Override
	protected void paintComponent(Graphics g) {
		if (g instanceof Graphics2D) {
			Graphics2D g2 = (Graphics2D) g;
			// On défini notre gradient selon les éléments calculé dans getTableCellRendererComponent() :
			// On part de la couleur de la ligne vers la couleur par défaut
			g2.setPaint(new GradientPaint(this.gradientX, 0, this.gradientColor, this.gradientWidth, getHeight(), getBackground()));
		} else {
			// Cas particulier où l'on n'aurait pas un Graphics2D :
			// On utilise la couleur de fond par défaut !
			// (il me semble que cela peut être le cas lors de l'impression)
			g.setColor(getBackground());
		}
		// Obn dessine le fond (en dégradé)
		g.fillRect(0, 0, getWidth(), getHeight());
		// Et on dessine le composant de manière standard :
		super.paintComponent(g);
	}
}

Exemple :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
		Object[] title = { "Décimal", "Binaire", "Octal", "Hexa" };
		Object[][] data = new Object[8196][];
		for (int i=0; i<data.length; i++) {
			data[i] = new Object[] { i, Integer.toBinaryString(i), String.format("%04o", i), String.format("%04X", i) };
		}
 
		JTable table = new JTable(data, title);
		table.setDefaultRenderer(Object.class, new GradientTableCellRenderer(Color.LIGHT_GRAY, Color.GRAY));
 
		JScrollPane pane = new JScrollPane(table);
		pane.setPreferredSize(new Dimension(200,400));
 
		JOptionPane.showMessageDialog(null, pane);

Cela ne me semble pas contre performant...


Maintenant il y a peut-être moyen de faire plus efficace en s'attaquant au TableUI... mais ce ne sera pas forcément simple !

a++

[bouye]

Il faut éviter les appels de méthodes graphiques dans un renderer (comme paint, repaint...), ça bouffe de la CPU et de la RAM.

Ce n'est pas performant du tout...

Il vaut mieux travailler avec le paint de la JTable.

Ridicule comme reflexion surtout quand on doit creer ses propres renderer personalises (pour representer par exemple un stroke, un paint ou autre). On tape soit dans le rendu graphique du render soit dans le rendu graphique d'un composant lui-meme inclus dans le renderer ce qui revient au meme. Et c'est ce que fait deja le renderer par defaut nottament pour l'affichage des boolean ou quand on met une icone sur le renderer (les icones de la checkbox ou du label sont dessinees lors du rendu).

Comme l'a dit adiGuba, le renderer est peint directement par la JTable aux endroits ou il apparait (et sa configuration change pour chaque element) mais la table a generalement le bon sens de ne l'appeler que quand cela est necessaire (en optimisant sa detection des zones surlequelles sont appellees les repaint() comme tous les autres JComponent, voir le code source des differentes UI dans src.zip).