JPanel : paintComponent jamais appelée

Version imprimable

Bonjour à tous,

Je n'ai pas trouvé de solution à mon problème dans les nombreux sujets des courageux Swing-nautes, donc je le détaille ici, en espérant que vous pourrez m'aider :

J'ai créé une classe Pix qui étend JPanel, et qui est censée (comme n'importe quel composant) se redessiner n'importe quand, par un mouvement de la JFrame ou par un événement souris préalablement créé.

Voici ma classe Pix :

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
package colorCross;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
 
import javax.swing.BorderFactory;
import javax.swing.JPanel;
 
public class Pix extends JPanel {
 
	private static final long serialVersionUID = 1L;
 
	private final PlayableGridModel model;
	private final Point coord;
	private final Color color;
 
	public Pix(Color border, int borderWidth,
			Color helpBorder, int helpBorderWidth,
			int x, int y,
			int width, int height,
			int helpRhythm, PixSizes size,
			PlayableGridModel m, Color c) {
		super(null);
		model = m;
		color = c;
		coord = new Point(x, y);
		setPreferredSize(new Dimension(size.getPixSize(), size.getPixSize()));
		setLayout(new BorderLayout());
		JPanel p = new JPanel(new BorderLayout()); {
			int top = (y != 0 && y % helpRhythm == 0) ? helpBorderWidth : 0,
				left = (x != 0 && x % helpRhythm == 0) ? helpBorderWidth : 0,
				bottom = 0,
				right = 0;
			if (top != 0 || left != 0) {
				p.setBorder(BorderFactory.createMatteBorder(top, left, bottom, right, helpBorder));
			}
			JPanel q = new JPanel(new BorderLayout()); {
				int top0 = (y != 0 && y % helpRhythm == 0) ? 0 : borderWidth,
					left0 = (x != 0 && x % helpRhythm == 0) ? 0 : borderWidth,
					bottom0 = (y == height - 1) ? borderWidth : 0,
					right0 = (x == width - 1) ? borderWidth : 0;
				q.setBorder(BorderFactory.createMatteBorder(top0, left0, bottom0, right0, border));
				q.setPreferredSize(new Dimension(size.getPixSize(), size.getPixSize()));
				q.add(new JPanel());
			}
			p.add(q);
		}
		add(p);
		System.out.println("create " + this.toString());
	}
 
	public JPanel getLastChild() {
		return (JPanel) ((JPanel) ((JPanel) getComponent(0)).getComponent(0)).getComponent(0);
	}
 
	public void paintComponent(Graphics g) {
		System.out.println("paintComponent");
		model.getPixState(coord.x, coord.y).drawPix(getLastChild(), color);
	}
 
}

Et voici, dans une autre classe, la méthode qui gère les changements :

Code:

1
2
3
4
5
6
	private void colorPix(int x, int y) {
		System.out.println("colorpix - begin");
		System.out.println(grid.get(model.getActualColor()).get(x).get(y).toString());
		grid.get(model.getActualColor()).get(x).get(y).repaint();
		System.out.println("colorpix - end");
	}

Avec ça, j'obtiens en console :

Code:

1
2
3
colorpix - begin
colorCross.Pix[,80,80,20x20,layout=java.awt.BorderLayout,alignmentX=0.0,alignmentY=0.0,border=,flags=9,maximumSize=,minimumSize=,preferredSize=java.awt.Dimension[width=20,height=20]]
colorpix - end

J'en déduis que la méthode paintComponent de Pix n'est pas appelée...

Par ailleurs, avec cette version de la méthode :

Code:

1
2
3
4
5
6
	private void colorPix(int x, int y) {
		model.getPixState(x, y).drawPix(
				grid.get(model.getActualColor()).get(x).get(y).getLastChild(),
				model.getActualColor()
		);
	}

Le Pix change effectivement d'état (mais au mouvement de la JFrame, il revient à son état initial, puisque son paintComponent n'est pas appelé...

Voilà, j'espère que j'ai été assez clair... Dans l'attente de vos suggestions, et un grand merci d'avance ;)

18/07/2013, 01h59
ZodiacLoyal

Bon, j'ai résolu le problème d'une façon un peu alambiquée : je n'étends plus JPanel mais JComponent, et ça fonctionne, Dieu sait pourquoi.

Je ne marque pas "Résolu", au-cas-où quelqu'un ait une réponse propre à ce souci.
18/07/2013, 13h53
tchize_

Etant donné qu'un JPanel, c'est un JComponent avec un layout, ça ne devrais pas changer grand chose.

quelques remarques, toute fois:

tu fais un super(null) puis tu fais un setLayout -> passe directement ce layout à super pour gagner en lisibilité

La méthode getLastChild explorer dynamiquement le contenu du JPanel, il serait préférable de stocker simplement ce new JPanel comme champ de ta classe, encore une fois, pour la lisibilité.

Tu semble emboiter les JPanel (p et q) juste pour combiner des bords.... Crée directement un seul bord avec le dessin que tu désirer et applique le directement à ton Pix, afin d'éviter de créer trop de composant avec les ressources qui vont avec. Le CompoundBorder est ton amis pour combiner :)

Je suis aussi perplexe que toi : lorsque j'avais Pix extends JPanel, un repaint() appelait JComponent.paintComponent(...), alors que maintenant que j'ai Pix extends JComponent, un repaint() appelle bien Pix.paintComponent(...). C'est très curieux...

Pour mes histoires de bordures, effectivement, c'était pour avoir des bordures de couleurs différentes... Pas très propre mais efficace (mon prof d'IHM me lyncherait).

Au final, comme j'utilise un JComponent, qui n'a donc pas de LayoutManager, je dessine la bordure à la main dans paintComponent, comme suit :

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
package colorCross;
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
 
import javax.swing.JComponent;
 
public class Pix extends JComponent {
 
	private static final long serialVersionUID = 1L;
 
	private final PlayableGridModel model;
	private final Point coord;
	private final Color color;
 
	public Pix(int x, int y, PixSizes size, PlayableGridModel m, Color c) {
		model = m;
		color = c;
		coord = new Point(x, y);
		setPreferredSize(new Dimension(size.getPixSize(), size.getPixSize()));
	}
 
	public void paintComponent(Graphics g) {
		int start_x = 0,
			start_y = 0;
 
		// Bordure classique
		// A gauche
		if (coord.x == 0 || coord.x % GridConstants.HELP_RHYTHM != 0) {
			g.setColor(GridConstants.BORDER_COLOR);
			g.fillRect(0, 0, GridConstants.BORDER_WIDTH, getHeight());
			start_x += GridConstants.BORDER_WIDTH;
		}
		// En haut
		if (coord.y == 0 || coord.y % GridConstants.HELP_RHYTHM != 0) {
			g.setColor(GridConstants.BORDER_COLOR);
			g.fillRect(0, 0, getWidth(), GridConstants.BORDER_WIDTH);
			start_y += GridConstants.BORDER_WIDTH;
		}
 
		// Bordure help
		// A gauche
		if (coord.x != 0 && coord.x % GridConstants.HELP_RHYTHM == 0) {
			g.setColor(GridConstants.HELP_SEE_COLOR);
			g.fillRect(0, 0, GridConstants.HELP_SEE_WIDTH, getHeight());
			start_x += GridConstants.HELP_SEE_WIDTH;
		}
		// En haut
		if (coord.y != 0 && coord.y % GridConstants.HELP_RHYTHM == 0) {
			g.setColor(GridConstants.HELP_SEE_COLOR);
			g.fillRect(0, 0, getWidth(), GridConstants.HELP_SEE_WIDTH);
			start_y += GridConstants.HELP_SEE_WIDTH;
		}
 
		// Contenu
 
		switch (model.getPixState(coord.x, coord.y)) {
		case FULL:
			g.clearRect(start_x, start_y, getWidth() - start_x, getHeight() - start_y);
			g.setColor(color);
			g.fillRect(start_x, start_y, getWidth() - start_x, getHeight() - start_y);
			break;
		case EMPTY:
			g.clearRect(start_x, start_y, getWidth() - start_x, getHeight() - start_y);
			break;
		case CROSSED:
			g.clearRect(start_x, start_y, getWidth() - start_x, getHeight() - start_y);
			g.setColor(color);
			g.drawLine(start_x, start_y, getWidth(), getHeight());
			g.drawLine(start_x, getHeight(), getWidth(), start_y);
			break;
		}
 
	}
 
}

Ça fait un peu plus McGyver, niveau bordures, mais ça fonctionne bien, donc en attendant de meilleures idées...