Discussion :

[francky74]

Bonjour,

Je rencontre des difficultés pour colorer le fond d'un JPanel. En fait j'ai imbriqué trois JPanel dans un autre avec le gridBagLayout mais je n'arive pas à les colorer.
D'après le forum, j'ai vu toutefois qu'il faut redéfinir la fonction paintComponent de JPanel. Mais après quelques essais infructueux, je suis dans l'impasse.

Voici le code de base (sans les essais de redéfinition de paintComponent) :

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
private void build(){
	setTitle("Jeu lettres");
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        setBounds(0,0,screenSize.width, screenSize.height);
	setLocationRelativeTo(null);
	setResizable(false);
	setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
	setContentPane(buildContentPane());
}
 
private JPanel buildContentPane() {
	JPanel panel = new JPanel(new GridBagLayout());
	panel.setOpaque(false);
	panel.setForeground(Color.RED);
	JPanel panelAffich = new JPanel(new GridBagLayout());
	panelAffich.setForeground(Color.RED);
	panelAffich.setOpaque(false);
	panelAffich.setVisible(true);
	panelAffich.setBackground(Color.BLUE);
	JButton bout = new JButton("MY BOUTON");
	JPanel panelBoutons = new JPanel(new GridBagLayout());
	panelBoutons.add(bout);
	panelBoutons.setOpaque(false);
	panelBoutons.setBackground(Color.RED);
	JPanel panelScore = new JPanel(new GridBagLayout());
	panelScore.setBackground(Color.YELLOW);
	panelScore.setOpaque(false);
 
	GridBagConstraints c = new GridBagConstraints();
 
	//contraintes pour le panneau d'affichage
 
	//Ajout paneau affichage texte
	c.fill = GridBagConstraints.HORIZONTAL;
	c.fill = GridBagConstraints.VERTICAL;
	c.gridx = 0;
	c.gridwidth = GridBagConstraints.REMAINDER;
	c.gridy = 0;
	c.gridheight = 1;
	c.insets = new Insets(10, 10, 10, 10);
	panel.add(panelAffich, c);
 
	//ajout paneau boutons
	c.fill = GridBagConstraints.VERTICAL;
	c.fill = GridBagConstraints.HORIZONTAL;
	c.gridx = 0;
	c.gridwidth = 3;
	c.gridy = 1;
	c.gridheight = 4;
	c.insets = new Insets(10, 10, 10, 10);
	panel.add(panelBoutons, c);
 
	//ajout panneau du score
	c.fill = GridBagConstraints.VERTICAL;
	c.fill = GridBagConstraints.HORIZONTAL;
	c.gridx = 1;
	c.gridwidth = 1;
	c.gridy = 1;
	c.gridheight = 4;
	c.insets = new Insets(10, 10, 10, 10);
	panel.add(panelScore, c);
 
	return panel;
}

si quelqu'un à la connaissance pour m'aider, je vous en remercie !

[joel.drigo]

Salut,

Il suffit d'affecter une couleur de fond (setBackground(Color)) pour avoir une couleur de fond à un JPanel. Inutile de redéfinir paintComponent() ou paint(). Par contre, il faut que le JPanel soit opaque évidemment (un panel non opaque est transparent au sens qu'il n'a pas de fond, donc pas de couleur de fond).

Autre évidence, cette couleur n'affectera que la panel, pas les composants qu'on y met :

• certains sont par défaut transparent (non opaque) par défaut, comme JLabel,
• d'autres sont opaques, donc ont leur propre fond, comme JPanel justement (il suffit de les rendre transparent donc, pour que leur panel parent apparaisse),
• et d'autres ont un fond plus complexe (qui est dessiné par un composant d'UI qui va dépendre du Look and Feel, donc pour lesquels il sera difficile de changer la couleur de fond sans perdre certains effets), comme Jbutton par exemple.

Par contre, inutile d'utiliser setForeground() si le JPanel n'est pas personnalisé pour l'utiliser : par défaut, un JPanel (opaque) ne dessine rien d'autre que son fond. Un foreground, c'est par exemple la couleur du texte d'un JLabel. On pourra utiliser un foreground dans un JPanel personnalisé qui dessine quelque chose de monocouleur comme par 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
public class JCustomPanel extends JPanel {
 
	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		g.setColor(getForeground());
		g.drawLine(0, 0, getWidth(), getHeight());
		g.drawLine(0, getHeight(), getWidth(), 0);
	}
 
	public static void main(String[] args) {
 
		JCustomPanel panel = new JCustomPanel();
		panel.setBackground(Color.GREEN);
		panel.setForeground(Color.RED);
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		frame.add(panel);
 
		frame.setSize(600, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
}

Qui va s'afficher comme ça :

[lankoande]

Salut francky,

Je ne sais paspourquoi vous avez désactiver l'opacité
des différents panneaux mais je pense que c'est la base du problème.
Il vous suffit d'activer l'opacité et c'est ok !

[lankoande]

Eh ! Joel a tout dis !
Je m'étais pas aperçu qu'il ya avait une réponse.
Merçi Joel pour ces explications bien claires.

[francky74]

Bonjour à tous ! et merci pour vos aides !

Joel :
Je ne comprends pas bien votre raisonnement.
Vous écrivez :

Inutile de redéfinir paintComponent() ou paint()

Mais dans votre exemple, vous overridez la méthode paintComponent().

Ce que j'ai compris c'est que si je n'ai pas besoin de personnaliser, je n'override pas paintComponent, et si j'ai un besoin de personnaliser, je vais overrider. C'est cela ?

Je testerai vos codes ce soir à la maison

Bonne journée,

[joel.drigo]

Mais dans votre exemple, vous overridez la méthode paintComponent().

paint() est la méthode public principale, qui appelle d'autres méthodes, donc paintComponent(). Selon ce qu'on veut faire, on en redéfinit une ou l'autre. Pour le fond, paintComponent() est la plus logique, mais pour un JPanel dans lequel on ne mettra jamais rien, on peut aussi bien faire ça dans paint(). Le choix de la méthode peut être due aussi sur le fait que ce qu'on veut dessiner soit au-dessus ou en-dessous des composants qu'on ajouterait au JPanel.

Ce que j'ai compris c'est que si je n'ai pas besoin de personnaliser, je n'override pas paintComponent, et si j'ai un besoin de personnaliser, je vais overrider. C'est cela ?

Absolument.

[francky74]

Bonjour,

Comme l'a écrit Lankoande, l'opacité doit prendre la valeur "true" puisque, comme l'a écrit Joel Drigo, je ne souhaite pas personnaliser.

J'ai donc passé l'opacité à true mais les couleurs de fond ne sont pas apparues....

Mais j'ai pensé que les layouts ne prenaient peut-être pas de place puisque je n'y ai pas de composants (enfin , il y a bien un bouton mais on ne voit pas le résultat d'un .foreground() ni d'un .background() à travers le bouton).

J'ai donc ajouté des labels car Joel a dit :

Un foreground, c'est par exemple la couleur du texte d'un JLabel.

Et là, je vois bien des couleurs que j'ai définies dans les panneaux ! En fait je pense que mes panneaux ont des dimensions de 0 ! donc invisibles comme vous pouvez le voir sur la copie d'écran :


Donc, il faut que je puisse redimensionner mes panneaux pour qu'ils prennent toute la place de la case du gridBagLayout dans lequel ils sont (j'imbrique des panneaux dans des cases d'un gridBagLayout ...). Mais le .setSize() ne fonctionne pas (dans le code en ligne 8).

voici le code où j'en suis (il y a pleins de trucs car je fait des expérimentations pour parvenir à mes fins ....) :

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
private JPanel buildContentPane() {
	JPanel panel = new JPanel(new GridBagLayout());
	panel.setOpaque(false);
	panel.setBackground(Color.RED);
	JLabel label1 = new JLabel("couleur !!!");
	JPanel panelAffich = new JPanel(new GridBagLayout());
	panelAffich.add(label1);
	panelAffich.setSize(200, 200);
	panelAffich.setOpaque(true);
	panelAffich.setVisible(true);
	panelAffich.setBackground(Color.BLUE);
	JButton bout = new JButton("MY BOUTON");
	JLabel label2 = new JLabel("couleur !!!");
	JPanel panelBoutons = new JPanel(new GridBagLayout());
	panelBoutons.add(bout);
	panelBoutons.setOpaque(true);
	panelBoutons.setForeground(Color.YELLOW);
	panelBoutons.add(label2);
	panelBoutons.setBackground(Color.RED);
	JPanel panelScore = new JPanel(new GridBagLayout());
	panelScore.setBackground(Color.YELLOW);
	panelScore.setOpaque(true);
 
	GridBagConstraints c = new GridBagConstraints();
 
	//contraintes pour le panneau d'affichage
 
	//Ajout paneau affichage texte
//	c.fill = GridBagConstraints.HORIZONTAL;
//	c.fill = GridBagConstraints.VERTICAL;
	c.gridx = 0;
	c.gridwidth = GridBagConstraints.REMAINDER;
	c.gridy = 0;
	c.gridheight = 1;
	c.insets = new Insets(10, 10, 10, 10);
	panel.add(panelAffich, c);
 
	//ajout paneau boutons
	c.fill = GridBagConstraints.VERTICAL;
	c.fill = GridBagConstraints.HORIZONTAL;
	c.gridx = 0;
	c.gridwidth = 3;
	c.gridy = 1;
	c.gridheight = 4;
	c.insets = new Insets(10, 10, 10, 10);
	panel.add(panelBoutons, c);
 
	//ajout panneau du score
	c.fill = GridBagConstraints.VERTICAL;
	c.fill = GridBagConstraints.HORIZONTAL;
	c.gridx = 1;
	c.gridwidth = 1;
	c.gridy = 1;
	c.gridheight = 4;
	c.insets = new Insets(10, 10, 10, 10);
	panel.add(panelScore, c);
 
	return panel;
}

Quelqu'un connait-il la méthode de contrainte qui pourra faire prendre toute la place aux panneaux ? le setSize() n'a pas fonctionné ...

Merci !!

[joel.drigo]

C'est quel panel que tu veux mettre en couleur ? Ce n'est pas le fond ?

Ce code est contradictoire : tu dis que le panel est non opaque et qu'il est de fond rouge ! Soit il est opaque et de fond rouge, soit il n'est pas opaque et pas rouge.

Code :

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

1
2
3
JPanel panel = new JPanel(new GridBagLayout());
	panel.setOpaque(false); // 
	panel.setBackground(Color.RED);

Donc c'est soit :

Code :

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

1
2
JPanel panel = new JPanel(new GridBagLayout());
panel.setBackground(Color.RED);

Code :

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

1
2
JPanel panel = new JPanel(new GridBagLayout());
panel.setOpaque(false);

Mais pas les deux en même temps.


PS : et ça panelBoutons.setForeground(Color.YELLOW); ne sert à rien... panelBoutons n'a rien qui se dessine en avant-plan.

PS2 : tu mets un GridBagLayout sur tous les JPanels, mais sur certains, tu y ajoutes tous les composants sans contrainte, et tu dimensionnes en dur ! Soit on dimensionne en dur, soit on utilise un GridBagLayout, pas le deux. Chaque composant devrait avoir un GridBagConstraint différent au moins sur gridx et/ou gridy, sauf si tu n'as qu'un composant, auquel cas, ça ne sert à rien d'utiliser un GridBagLayout (le layout manager par défaut (Flowayout) suffit).

[joel.drigo]

Donc, il faut que je puisse redimensionner mes panneaux pour qu'ils prennent toute la place de la case du gridBagLayout dans lequel ils sont (j'imbrique des panneaux dans des cases d'un gridBagLayout ...). Mais le .setSize() ne fonctionne pas (dans le code en ligne 8).

Ça se gère par la contrainte ça : le paramètre fill peut prendre la valeur GridBagConstraint.BOTH pour s'étaler en largeur et hauteur.

[francky74]

Bonsoir !

C'est quel panel que tu veux mettre en couleur ? Ce n'est pas le fond ?

Il est vrai que mon code commence à contenir trop d'essais qui finissent pas se contredire.

Je souhaite colorer les panneaux "panelAffich", "panelBoutons" et "panelScore" dans le but de voir à l'écran quelle propotion ils vont prendre.

J'ai mis chacun de ces panneaux dans une case du gridBagLayout défini dans le panneau "panel".

PS : et ça panelBoutons.setForeground(Color.YELLOW); ne sert à rien... panelBoutons n'a rien qui se dessine en avant-plan.

Vous avez entièrement raison ! c'est un reste d'essais ... je vais nettoyer ce code ....

PS2 : tu mets un GridBagLayout sur tous les JPanels, mais sur certains, tu y ajoutes tous les composants sans contrainte, et tu dimensionnes en dur ! Soit on dimensionne en dur, soit on utilise un GridBagLayout, pas le deux. Chaque composant devrait avoir un GridBagConstraint différent au moins sur gridx et/ou gridy, sauf si tu n'as qu'un composant, auquel cas, ça ne sert à rien d'utiliser un GridBagLayout (le layout manager par défaut (Flowayout) suffit).

En fait les griodBagLayouts que j'ai ajouté aux panneaux "panelAffich", "panelBoutons" et "panelScore" vont être utilisés puisque le panelBoutons va acceuillir plus de boutons que de lettres de l'alphabet (je fait un jeu de lettres pour mes enfants qui apprennent à lire). le panel score acceuillera plusieurs affichages.
Quant au panelAffich, il ne devrait acceuillir qu'un texte donc celui là pourrait être plus simple qu'un gridBadLayout.

cette ligne :

Code :

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

1
2
 
c.fill = GridBagConstraints.BOTH;

ne vaut-elle pas ceci :

Code :

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

1
2
c.fill = GridBagConstraints.HORIZONTAL;
c.fill = GridBagConstraints.VERTICAL;

Merci pour votre aide !

[joel.drigo]

Voilà des exemples pour différentes combinaisons. Dans cet exemple, j'utilise la même instance de GridBagConstraint pour ne pas à avoir à préciser à chaque fois ce qui ne change pas, mais ça veut dire qu'il faut penser à remettre à zéro ce qui est nécessaire. Tu peux si tu veux être sûr de ne rien oublier faire le new GridBagConstraints dans chaque bloc.

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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
	public static void main(String[] args) {
 
		JPanel panel = new JPanel(new GridBagLayout());
		panel.setBackground(Color.GREEN); // fond vert
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		frame.add(panel);
 
		GridBagConstraints gbc = new GridBagConstraints(0, 0, 1, 1, 0, 0, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0,0,0,0), 0, 0);
 
		{
			gbc.gridx = 0; // position dans la grille : x=0
			gbc.gridy = 0; // position dans la grille : y=0
			gbc.fill = GridBagConstraints.NONE; // garde sa taille préférentielle
			JComponent component = new JLabel("AAAAA"); // composant : un texte sans fond non opaque par défaut, donc sur fond vert
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 1; // position dans la grille : x=1
			gbc.gridy = 0; // position dans la grille : y=0
			gbc.fill = GridBagConstraints.NONE; // garde sa taille préférentielle
			JComponent component = new JLabel("AAAAA"); // composant : un texte
			component.setOpaque(true); // opaque
			component.setBackground(Color.YELLOW); // avec fond jaune
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 2; // position dans la grille : x=2
			gbc.gridy = 0; // position dans la grille : y=0
			gbc.fill = GridBagConstraints.NONE; // garde sa taille préférentielle
			JComponent component = new JLabel("AAAAA"); // composant : un texte
			component.setOpaque(true); // opaque
			component.setBackground(Color.YELLOW); // avec fond jaune
			component.setForeground(Color.RED); // texte rouge
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 0; // position dans la grille : x=0
			gbc.gridy = 1; // position dans la grille : y=1
			gbc.fill = GridBagConstraints.HORIZONTAL; // s'étale en largeur
			gbc.weightx = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("BBBBB"); // composant : un texte sans fond non opaque par défaut, donc sur fond vert
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 1; // position dans la grille : x=1
			gbc.gridy = 1; // position dans la grille : y=1
			gbc.fill = GridBagConstraints.HORIZONTAL; // s'étale en largeur
			gbc.weightx = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("BBBBB"); // composant : un texte
			component.setOpaque(true); // opaque
			component.setBackground(Color.YELLOW); // avec fond jaune
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 2; // position dans la grille : x=2
			gbc.gridy = 1; // position dans la grille : y=1
			gbc.fill = GridBagConstraints.HORIZONTAL; // s'étale en largeur
			gbc.weightx = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("BBBBB"); // composant : un texte
			component.setOpaque(true); // opaque
			component.setBackground(Color.YELLOW); // avec fond jaune
			component.setForeground(Color.RED); // texte rouge
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 0; // position dans la grille : x=0
			gbc.gridy = 2; // position dans la grille : y=2
			gbc.fill = GridBagConstraints.VERTICAL; // s'étale en hauteur
			gbc.weightx = 0; // reset
			gbc.weighty = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("CCCCC"); // composant : un texte sans fond non opaque par défaut, donc sur fond vert
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 1; // position dans la grille : x=1
			gbc.gridy = 2; // position dans la grille : y=2
			gbc.fill = GridBagConstraints.VERTICAL; // s'étale en hauteur
			gbc.weightx = 0; // reset
			gbc.weighty = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("CCCCC"); // composant : un texte
			component.setOpaque(true); // opaque
			component.setBackground(Color.YELLOW); // avec fond jaune
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 2; // position dans la grille : x=2
			gbc.gridy = 2; // position dans la grille : y=2
			gbc.fill = GridBagConstraints.VERTICAL; // s'étale en hauteur
			gbc.weightx = 0; // reset
			gbc.weighty = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("CCCCC"); // composant : un texte
			component.setOpaque(true); // opaque
			component.setBackground(Color.YELLOW); // avec fond jaune
			component.setForeground(Color.RED); // texte rouge
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 0; // position dans la grille : x=0
			gbc.gridy = 3; // position dans la grille : y=3
			gbc.fill = GridBagConstraints.BOTH; // s'étale en hauteur
			gbc.weightx = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			gbc.weighty = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("DDDDD"); // composant : un texte sans fond non opaque par défaut, donc sur fond vert
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 1; // position dans la grille : x=1
			gbc.gridy = 3; // position dans la grille : y=3
			gbc.fill = GridBagConstraints.BOTH; // s'étale en hauteur
			gbc.weightx = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			gbc.weighty = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("DDDDD"); // composant : un texte
			component.setOpaque(true); // opaque
			component.setBackground(Color.YELLOW); // avec fond jaune
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 2; // position dans la grille : x=2
			gbc.gridy = 3; // position dans la grille : y=3
			gbc.fill = GridBagConstraints.BOTH; // s'étale en hauteur
			gbc.weightx = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			gbc.weighty = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("DDDDD"); // composant : un texte
			component.setOpaque(true); // opaque
			component.setBackground(Color.YELLOW); // avec fond jaune
			component.setForeground(Color.RED); // texte rouge
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 0; // position dans la grille : x=0
			gbc.gridy = 4; // position dans la grille : y=4
			gbc.fill = GridBagConstraints.BOTH; // s'étale en hauteur
			gbc.weightx = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			gbc.weighty = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("EEEEE", JLabel.CENTER); // composant : un texte sans fond non opaque par défaut, donc sur fond vert et centré
			component.setBorder(BorderFactory.createLineBorder(Color.BLUE)); // bordure bleue fine
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 1; // position dans la grille : x=1
			gbc.gridy = 4; // position dans la grille : y=4
			gbc.fill = GridBagConstraints.BOTH; // s'étale en hauteur
			gbc.weightx = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			gbc.weighty = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("EEEEE", JLabel.CENTER); // composant : un texte  centré
			component.setOpaque(true); // opaque
			component.setBackground(Color.YELLOW); // avec fond jaune
			component.setBorder(BorderFactory.createLineBorder(Color.BLUE)); // bordure bleue fine
			panel.add(component, gbc);
		}
 
		{
			gbc.gridx = 2; // position dans la grille : x=2
			gbc.gridy = 4; // position dans la grille : y=4
			gbc.fill = GridBagConstraints.BOTH; // s'étale en hauteur
			gbc.weightx = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			gbc.weighty = 1; // il faut indiquer quelle proportion de l'espace disponible on va prendre pour s'étaler (tous les 3 à la même valeur, 1, donc chacun prendre le même espace)
			JComponent component = new JLabel("EEEEE", JLabel.CENTER); // composant : un texte centré
			component.setOpaque(true); // opaque
			component.setBackground(Color.YELLOW); // avec fond jaune
			component.setForeground(Color.RED); // texte rouge
			component.setBorder(BorderFactory.createLineBorder(Color.BLUE)); // bordure bleue fine
			panel.add(component, gbc);
		}
 
 
		frame.setSize(600, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}

Résultat :

[francky74]

Merci pour ce bel exemple !

Comme il n'imbrique pas de panneau dans la grille, j'ai fait un essai en rajoutant les lignes de code pour mettre un panneau dans la case (0, 0), et je vois la coloration du panneau ! :

Code :

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

1
2
3
4
5
6
7
8
{
	gbc.gridx = 0; // position dans la grille : x=0
	gbc.gridy = 0; // position dans la grille : y=0
	gbc.fill = GridBagConstraints.BOTH; // taille maxi
	JPanel panel2 = new JPanel(new GridBagLayout());
	panel2.setBackground(Color.BLACK);
	panel.add(panel2, gbc);
}

et cela fonctionne, on peut voir le rectangle noir en haut à gauche ! je vais donc corriger mon code pour aboutir à mes souhaits ! Je viendrais poster mon code ici une fois bien propre ...

Merci !

[francky74]

Bonsoir,

Je ne comprend pas trop ce qui se passe là .... j'ai pourtant l'impression d'avoir bien compris avec votre exemple.
Pourtant, je ne parviens à afficher qu'un fenêtre grise monotone ....

J'ai fait un essai sur le panel (celui qui doit recevoir les autres panneaux dans son gridBagLayout) qui a fonctionné. j'ai coloré ce panneau en noir et ma fenêtre a bien été colorée en noir.
Mais pourquoi les autres panneaux ne se colorent-ils pas ?
voici l'essai que j'ai réalisé puis effacé (car ce n'est pas mon but final). j'ai inséré ce code après la déclaration du panel, juste après le ligne 9 :

Code :

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

panel.setBackground(Color.BLACK);

Voici le code que j'ai fait (bien plus propre qu'auparavant ..) :

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
private void build(){
	JFrame frameJeu = new JFrame("jeu Lettres");
	frameJeu.setTitle("Jeu lettres");
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        frameJeu.setBounds(0,0,screenSize.width, screenSize.height);
        frameJeu.setResizable(false);
        frameJeu.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
	JPanel panel = new JPanel(new GridBagLayout());
 
	frameJeu.add(panel);
 
	JPanel panelAffich = new JPanel(new GridBagLayout());
	panelAffich.setBackground(Color.BLUE);
 
	JPanel panelBoutons = new JPanel(new GridBagLayout());
	panelAffich.setBackground(Color.RED);
 
	JPanel panelScore = new JPanel(new GridBagLayout());
	panelScore.setBackground(Color.YELLOW);
 
	GridBagConstraints c = new GridBagConstraints(0, 0, 1, 1, 0, 0, GridBagConstraints.CENTER,  GridBagConstraints.NONE, new Insets(0,0,0,0), 0, 0);
 
	//contraintes pour le panneau d'affichage
	{
		//Ajout paneau affichage texte
		c.gridx = 0;
		c.gridwidth = 1;
		c.gridy = 0;
		c.fill = GridBagConstraints.BOTH;
		panel.add(panelAffich, c);
	}
	{
		//ajout paneau boutons
		c.gridx = 0;
		c.gridwidth = 3;
		c.gridy = 1;
		c.gridheight = 4;
		c.fill = GridBagConstraints.BOTH;
		c.insets = new Insets(10, 10, 10, 10);
		panel.add(panelBoutons, c);
	}
	{
		//ajout panneau du score
		c.gridx = 1;
		c.gridwidth = 1;
		c.gridy = 1;
		c.gridheight = 4;
		c.fill = GridBagConstraints.BOTH;
		panel.add(panelScore, c);
	}
	frameJeu.setVisible(true);
    frameJeu.setLocationRelativeTo(null);
}

[joel.drigo]

1. Le fait d'affecter un GridBagLayout à un JPanel fait que sa taille préférentielle dépend des composants qui s'y trouvent. Comme il n'y a aucun composant dans panelAffich, panelBoutons et panelScore, ils font tous 0x0 de taille préférentielle (comme de taille maxi et mini d'ailleurs) ;
2. Tu les mets dans un panel qui a un GridBagLayout : leur taille va dépendre de règles correspondant au fonctionnement de ce layout manager. Tu indiques pour tous qu'il doivent s'étendre au maximum, mais tu nndiques que la proportion de l'espace disponible sur lequel ils doivent s'étendre est de 0 en largeur et 0 en hauteur.
   

   Code :

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

   new GridBagConstraints(0, 0, 1, 1, 0, 0, GridBagConstraints.CENTER,  GridBagConstraints.NONE, new Insets(0,0,0,0), 0, 0);

   Ces paramètres correspondent aux attributs weightx et weighty. Comme cette proportion est de 0, le composant ne s'étend pas, malgré la contrainte GridBagConstraints.BOTH
3. Attention à gridwidth et gridheight (dont je n'avais pas parlé) : il s'agit respectivement du nombre de colonnes et de lignes occupés par le composant. Un peu comme le colspan et le rowspan html. Il faut en tenir compte dans les position gridx et gridy, sinon tu auras des superpositions. Par exemple, comme panelBoutons est en 0,1,3,4, les cases occupées sont
   

   0,1	1,1	2,1
   0,2	1,2	2,2
   0,3	1,3	2,3
   0,4	1,4	2,4

   
   
   Or panelScore est en 1,1,1,4 :
   
   

   	1,1
   	1,2
   	1,3
   	1,4

   
   Donc au même endroit. Comme les composants s'affichent dans l'ordre inverse de leur ajout dans leur conteneur, le panelScore jaune est complètement masqué par le panelBoutons rouge
   
4. Attention avec les insets et la réutilisation de c.
   
   Les composants panelBoutons et panelScore ont les mêmes insets (marges d'espacement inter composant) : est-ce voulu ?
   
5. Attention à l'erreur ici aussi :
   

   Code :

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

   1
   2
   JPanel panelBoutons = new JPanel(new GridBagLayout());
   	[b]<span class="highlight">panelAffich</span>.setBackground(Color.RED);

   C'est évidemment :
   

   Code :

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

   1
   2
   JPanel panelBoutons = new JPanel(new GridBagLayout());
   	panelBoutons.setBackground(Color.RED);

Je ne sais pas quelle présentation tu cherches à obtenir, mais je pense à ça plutôt :

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
JFrame frameJeu = new JFrame("jeu Lettres");
		frameJeu.setTitle("Jeu lettres");
	        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
	        frameJeu.setBounds(0,0,screenSize.width, screenSize.height);
	        frameJeu.setResizable(false);
	        frameJeu.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		JPanel panel = new JPanel(new GridBagLayout());
 
		frameJeu.add(panel);
 
		JPanel panelAffich = new JPanel();
		panelAffich.setBackground(Color.BLUE);
 
		JPanel panelBoutons = new JPanel();
		panelBoutons.setBackground(Color.RED); // !
 
		JPanel panelScore = new JPanel();
		panelScore.setBackground(Color.YELLOW);
 
		GridBagConstraints c = new GridBagConstraints(0, 0, 1, 1, 1, 1, GridBagConstraints.CENTER,  GridBagConstraints.NONE, new Insets(0,0,0,0), 0, 0);
 
		//contraintes pour le panneau d'affichage
		{
			//Ajout paneau affichage texte
			c.gridx = 0;
			c.gridy = 0;
			c.gridwidth = 2;
			c.gridheight = 1;
			c.weightx = 1;
			c.weighty = 3;
			c.fill = GridBagConstraints.BOTH;
			panel.add(panelAffich, c);
		}
		{
			//ajout paneau boutons
			c.gridx = 0;
			c.gridy = 1;
			c.gridwidth = 1;
			c.gridheight = 1;
			c.weightx = 1;
			c.weighty = 1;
			c.fill = GridBagConstraints.BOTH;
			c.insets = new Insets(10, 0, 0, 0);
			panel.add(panelBoutons, c);
		}
		{
			//ajout panneau du score
			c.gridx = 1;
			c.gridy = 1;
			c.gridwidth = 1;
			c.gridheight = 1;
			c.weightx = 1;
			c.weighty = 1;
			c.fill = GridBagConstraints.BOTH;
			c.insets = new Insets(10, 10, 0, 0);
			panel.add(panelScore, c);
		}
		frameJeu.setVisible(true);
	    frameJeu.setLocationRelativeTo(null);

[francky74]

Bonsoir et merci pour votre aide !


Grace à vos conseils, je m'approche de ce que je recherche.

Je ne sais pas quelle présentation tu cherches à obtenir

J'ai fait un croquis sur Calc en respectant les couleurs des layouts. Ce croquis me permet de définir les proportions que je souhaite donner aux panneaux du layout :

On peut voir que :
-Le panelAffich de couleur bleue prend toute la largeur (9 cases) et seulement deux cases en hauteur. Il est positionné sur la case 0,0 (x, y).
-Le panelBoutons de couleur rouge prend 6 cases de largeur et 7 cases de hauteur. il est positioné sur la case 0, 2 (x, y)
-Le panneauScore de couleur jaune prend 3 cases de largeur et 7 cases de hauteur. il est positionné sur la case 6, 2 (x, y).

--> le problème avec ce genre de représentation, c'est que les cases de Calc n'ont pas les même dimensions que les cases du gridBagLayout ....
Donc, pour me conformer à ces proportions, j'ai édité le code ci-dessous :

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
private void build(){
	JFrame frameJeu = new JFrame("jeu Lettres");
	frameJeu.setTitle("Jeu lettres");
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        frameJeu.setBounds(0,0,screenSize.width, screenSize.height);
        frameJeu.setResizable(false);
        frameJeu.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
	JPanel panel = new JPanel(new GridBagLayout());
 
	frameJeu.add(panel);
 
	JPanel panelAffich = new JPanel(new GridBagLayout());
	panelAffich.setBackground(Color.BLUE);
 
	JPanel panelBoutons = new JPanel(new GridBagLayout());
	panelBoutons.setBackground(Color.RED);
 
	JPanel panelScore = new JPanel(new GridBagLayout());
	panelScore.setBackground(Color.YELLOW);
 
	GridBagConstraints c = new GridBagConstraints(0, 0, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0,0,0,0), 0, 0);
 
	//contraintes pour le panneau d'affichage
	{
		//Ajout paneau affichage texte
		c.gridx = 0;
		c.gridy = 0;
		c.gridwidth = 9;
		c.gridheight = 2;
		c.fill = GridBagConstraints.BOTH;
		panel.add(panelAffich, c);
	}
 
	{
		//ajout paneau boutons
		c.gridx = 0;
		c.gridy = 2;
		c.gridwidth = 6;
		c.gridheight = 7;
		c.fill = GridBagConstraints.BOTH;
		panel.add(panelBoutons, c);
	}
 
	{
		//ajout panneau du score
		c.gridx = 6;
		c.gridy = 2;
		c.gridwidth = 3;
		c.gridheight =7;
		c.fill = GridBagConstraints.BOTH;
		panel.add(panelScore, c);
	}
	frameJeu.setVisible(true);
    frameJeu.setLocationRelativeTo(null);
}

J'ai laissé les weightx et weighty à 1 mais je ne sais pas si j'ai raison de faire cela. Je n'ai pas trop compris le rôle de ces paramètres.
Dans le document de JM DOUDOUX (http://jmdoudoux.developpez.com/cours/developpons/java/), il est écrit ceci :

Permettent de définir la répartition de l'espace en cas de changement de dimension

Ma fenêtre ne change jamais de dimension. Mais parle-t-il du changement de dimension d'un panneau à un autre ? de ce qui change dans gridBagConstraint ?

et voici ce que cela donne à l'exécution :


Il me faudrait rétrécir la hauteur du panelAffich, et élargir la largeur dupanelBoutons (et aussi diminuer la largeur du pannelScore).

Donc je travaille à cela maintenant.

Dans tous les cas, ayant réussi à colorer mes panels, je clos ce sujet et vous remercie pour votre aide

[joel.drigo]

Il faut bien comprendre qu'il y a quatres "Entités" :

1. Le conteneur layouté par un GridBagLayout
2. Les composants qu'on met dans 1
3. La grille
4. Le conteneur de 1 (qui a son propre layout : si c'est le conteneur par défaut d'une JFrame, c'est un JLayeredPane, une sorte de JPanel pour simplifier, qui est layouté avec un BorderLayout : le composant 1 étant placé par défaut au centre (quand on fait frame.add(panel), ou frame.getContentPane().add(panel))) s'étale donc complètement dans le centre, donc complètement dans la frame (s'il n'y a rien dans les autres zones, est, ouest, nord et sud), bordures et titre mis à part (s'étale sur l'intérieur de la frame).

La taille de la grille (3) dépend des composants (2) et de leur contrainte.

Par défaut, avec weightx=weighty=0, les composants se dimensionnent par rapport à leur taille préférentielle. La taille de la grille est la combinaison de ces tailles : je parle de combinaison parce que ça dépend où se trouvent les composants. Prenons un cas simple : si tous les composants sont mis dans la même ligne, la largeur de la grille est la somme des largeurs des composants (additionnés des éventuels insets droites et gauches si on en met), et sa hauteur, la hauteur du plus haut des composants. Si on met 4 composants, en position (0,0), (1,0), (0,1), (1,1), donc comme ça :

a	b
c	d

La largeur est max( largeur(a)+largeur(b), largeur(c)+largeur(d)) et la hauteur est max( hauteur(a)+hauteur(c), hauteur(b)+hauteur(d) )

Ensuite, gridwidth et gridheight, sont, comme je l'ai dit avant, un peu comme colspan et rowspan. Ils permettent juste de dire qu'un composant remplit plus d'une case de la grille lorsqu'ils valent autre chose que 1.

Pour gridwidth = 2, le composant occupe 2 cases en largeur.
Pour gridheight = 2, le composant occupe 2 cases en hauteur.

La taille de la grille en est influencée, mais pas la taille des composants eux-même. Par exemple, si on a :

a	a
c	d

La largeur de la grille est max( largeur(a), largeur(c)+largeur(d) ), et sa hauteur = max( hauteur(a)+hauteur(c), hauteur(a)+hauteur(d)).

lorsqu'on utilise une contrainte d'étalement, comme GridBagConstraint.BOTH, le composant va chercher à s'étaler dans le conteneur (1). Ce qui va changer la taille de la grille bien sûr.

Simplifions en ne parlant que de la largeur. Imaginons que la largeur de 4 fait 100 pixels. Imaginons 2 composants en largeur, a, de 30 pixels de large, et b de 30 pixels de large.

Sans étalement, on a une grille de 60 pixels de large, qui s'affiche au milieu d'un composant qui fait 100 pixels de large, donc avec des bandes de 20 pixels de part et d'autre.

weightx nous permet de dire comment l'espace de ces bandes va être réparti entre a et b pour qu'ils s'étalent.

Si weightx est le même pour a et b, ça veut dire qu'on veut qu'ils se répartissent l'espace de manière équitable : chacun des 2 va donc prendre le même espace, et ils feront donc tous les deux 50 pixels de large.

Si weightx de a fait 2, et weightx de b fait 1, ça veut dire que a prendra 2 fois plus d'espace disponible que b. Ou encore que l'espace disponible sera réparti au deux tiers pour a, et à un tiers pour b, soit 2*40/3 pixels pour a, qui fera donc 30+27=57 pixels, et et 40/3 pour b, qui fera 30 + 13, soit 43 pixels, pour occuper tous les deux 100 pixels de large.

Pour déterminer les gridwidth et gridheight, il ne faut regarder que les composants, pas la grille que tu as dessinée. Pour la répartition dans cette grille, par contre, il faut justement utiliser weightx et weighty.

Pour gridx, gridy, gridwidth et gridheight, il faut juste regarder combien de formes de couleur on a en hauteur et largeur : c'est une grille de 2x2 du type :

bleu	bleu
rouge	jaune

donc les gridx, gridy, gridwidth, gridheight sont :

• 0,0,2,1 pour bleu
• 0,1,1,1 pour rouge
• 1,1,1,1 pour jaune

tout simplement.


Pour weightx et weighty, il faut compter le cases de la grille (c'est justement bien d'avoir fait une grille pour ça), mais en tenant compte des rapports au nombre total de cases.

En largeur, rouge prend 6/9, jaune 3/9, et bleu 9/9. (en simplifiant : 2/3=6/9, 1/3=3/9, et 1=3/3=9/9)

En hauteur, bleu prend 2/9, et jaune et rouge 7/9.



Voici l'illustration de tout ça par le code :

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
public class GridBagLayoutDemo {
 
 
	public static void main(String[] args) {
 
		JPanel panel = new JPanel(new GridBagLayout());
 
		JPanel gridPanel = new JPanel(new GridBagLayout());
		gridPanel.setOpaque(false);
 
		JFrame frame = new JFrame("Démo");
		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		frame.getContentPane().setLayout(new OverlayLayout(frame.getContentPane())); // ça c'est juste pour la démo, pour afficher la grille au dessus
 
 
		frame.add(gridPanel);
		frame.add(panel);
 
		addPanel( panel, Color.BLUE,   0,  0,  2,  1,  3,  2 );
		addPanel( panel, Color.RED,    0,  1,  1,  1,  2,  7 );
		addPanel( panel, Color.YELLOW, 1,  1,  1,  1,  1,  7 );
 
		addGridPanel( gridPanel, 0,  0,  9, 2 );
		addGridPanel( gridPanel, 0,  2,  6, 7 );
		addGridPanel( gridPanel, 6,  2,  3, 7 );
 
		frame.setSize(600, 400);
		frame.setLocationRelativeTo(null);
		frame.setVisible(true);
 
	}
 
	private static void addPanel(JPanel panel, Color color,
			int x, int y, int width, int height, int weightx, int weighty) {
 
		GridBagConstraints gbc = new GridBagConstraints(x, y, width, height, weightx, weighty, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0,0,0,0), 0, 0);
 
		JPanel panelColor = new JPanel();
		panelColor.setBackground(color);
		panel.add( panelColor, gbc );
 
	}
 
	private static void addGridPanel(JPanel gridPanel,
			int x, int y, int width, int height) {
 
		for( int i=0; i<width; i++) {
			for( int j=0; j<height; j++) {
				GridBagConstraints gbcGrid = new GridBagConstraints(x+i, y+j, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0,0,0,0), 0, 0);
				JPanel panelCase = new JPanel();
				panelCase.setOpaque(false);
				panelCase.setBorder(BorderFactory.createLineBorder(Color.BLACK));
				gridPanel.add( panelCase, gbcGrid );
			}
		}
 
 
	}
 
 
}

Les petits décalages et les marges sont dus aux arrondis : comme on travaille tout en entiers (les largeurs et hauteurs, les poids), on a des marges, et comme la répartition n'est pas exactement la même entre les 2 plans (les carrés de couleurs et la grille noire), on a des petits décalages. Il faudrait faire un changement d'échelle pour arriver à ce que ça colle exactement. En utilisant des valeurs plus grandes (beaucoup plus grandes) on gagne en précision, et on peut corriger plus facilement les erreurs dues aux arrondis. Au lieu de faire une répartion 6/3, on va faire une répartition 599/301 par exemple. J'ai mis ça au pif : il faudrait faire une petite fonction pour calculer la répartition au plus juste (en reproduisant l'algo du GridBagLayout), en fonction de la taille du conteneur de 1 (4). A priori, d'autres layout manager devraient permettrent de faire ça plus simplement (voire un layout manager personalisé).

[francky74]

Whaou ca tue ....

Impressionnant ! Explications claires et en plus vous avez fait les grilles dans la démo !

Je vous remercie beaucoup, domage je ne peux faire qu'un seul like ...

J'aime beaucoup la méthode addPanel() !

Je vois que tous les panels (le bleu, rouge ou le jaune) portent le même nom "panel.
Je n'ai pas besoin donc de recréer à chaque fois un nouveau panel ?

Par contre, je suis un peu perdu pour ajouter des panels différents.
Par exemple, ici j'ai juste remplacé le premier panel (bleu) par un panelAffich mais je ne sais pas trop comment l'ajouter à la frame ??

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
	private void build(){
 
		JPanel panel = new JPanel(new GridBagLayout());
		JPanel panelAffich = new JPanel(new GridBagLayout());
 
		JFrame frameJeu = new JFrame("jeu Lettres");
	    frameJeu.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
		frameJeu.add(panel);
 
		addPanel( panelAffich, Color.BLUE,   0,  0,  2,  1,  3,  2 );
		addPanel( panel, Color.RED,    0,  1,  1,  1,  2,  7 );
		addPanel( panel, Color.YELLOW, 1,  1,  1,  1,  1,  7 );
 
	    Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
	    frameJeu.setBounds(0,0,screenSize.width, screenSize.height);
	    frameJeu.setResizable(false);
 
		frameJeu.setVisible(true);
	    frameJeu.setLocationRelativeTo(null);
	}
	private static void addPanel(JPanel panel, Color color,
			int x, int y, int width, int height, int weightx, int weighty) {
 
		GridBagConstraints gbc = new GridBagConstraints(x, y, width, height, weightx, weighty, GridBagConstraints.CENTER, GridBagConstraints.BOTH, new Insets(0,0,0,0), 0, 0);
 
		JPanel panelColor = new JPanel();
		panelColor.setBackground(color);
		panel.add( panelColor, gbc );
 
	}
}

[francky74]

Voilà

j'ai enfin réussi ce que je désirais faire !

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
	private void build(){
		JFrame frameJeu = new JFrame("jeu Lettres");
		frameJeu.setTitle("Jeu lettres");
        Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize();
        frameJeu.setBounds(0,1,screenSize.width, screenSize.height);
        frameJeu.setResizable(false);
        frameJeu.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 
        JLabel labelMots = new JLabel("_ _ _ _ _ _ _ _ _ _", JLabel.CENTER);
        Font font = new Font("Arial", 1, (int)(screenSize.width * 0.05));
        labelMots.setFont(font);
        labelMots.setForeground(Color.WHITE);
        labelMots.setVisible(true);
        labelMots.setSize((int)(screenSize.width * 0.8), (int)(screenSize.height * 2 * 0.9 / 9));
		JPanel panel = new JPanel(new GridBagLayout());
        JLabel label2 = new JLabel("coucou2");
        JLabel label3 = new JLabel("coucou3");
 
		frameJeu.add(panel);
 
		JPanel panelAffich = new JPanel(new GridBagLayout());
		panelAffich.setBackground(Color.BLUE);
		panelAffich.add(labelMots);
 
		JPanel panelBoutons = new JPanel(new GridBagLayout());
		panelBoutons.setBackground(Color.RED);
		panelBoutons.add(label2);
 
		JPanel panelScore = new JPanel(new GridBagLayout());
		panelScore.setBackground(Color.YELLOW);
		panelScore.add(label3);
 
		GridBagConstraints c = new GridBagConstraints(0, 0, 1, 1, 1, 1, GridBagConstraints.CENTER, GridBagConstraints.NONE, new Insets(0,0,0,0), 0, 0);
 
		//contraintes pour le panneau d'affichage
		{
			//Ajout paneau affichage texte
			c.gridx = 0;
			c.gridy = 0;
			c.gridwidth = 2;
			c.gridheight = 1;
			c.weightx = 3;
			c.weighty = 2;
			c.fill = GridBagConstraints.BOTH;
			panel.add(panelAffich, c);
		}
 
		{
			//ajout paneau boutons
			c.gridx = 0;
			c.gridy = 1;
			c.gridwidth = 1;
			c.gridheight = 1;
			c.weightx = 2;
			c.weighty = 7;
			c.fill = GridBagConstraints.BOTH;
			panel.add(panelBoutons, c);
		}
 
		{
			//ajout panneau du score
			c.gridx = 1;
			c.gridy = 1;
			c.gridwidth = 1;
			c.gridheight = 1;
			c.weightx = 1;
			c.weighty = 7;
			c.fill = GridBagConstraints.BOTH;
			panel.add(panelScore, c);
		}
		frameJeu.setVisible(true);
	    frameJeu.setLocationRelativeTo(null);
	}
}

Merci