affichage dynamique d'un GridLayout

Bonjour à tous!
Voila je fais un petit projet de jeu. Je dispose d'une sorte de plateau sur lequel sont positionnées des cartes. Ce plateau est un JPanel, dans lequel je pose mes cartes grace à un GridLayout. Voici :

Citation:

JPanel jpanel = new JPanel(new GridLayout(il.getWidth(),il.getHeight())) ;
for(int j = 0 ; j< il.getWidth() ; j++)for(int i = 0 ; i< il.getHeight() ; i++)
jpanel.add( new CaseVue(il.getCase(i,j)));

Ça fonctionne mais maintenant, je veux changer la taille de mon plateau de jeu (le nombre de carte)! Par exemple je pars de 25 cartes, je passe à 100 en cliquant sur un bouton et je peux revenir à 25 en cliquant sur un autre.
Comment faire au niveau de l'affichage ?
Merci d'avance.

Utilise un cardLayout ça te permet de créer plusieurs JPanel ( 25 cartes - 100 cartes ) et d'en afficher un seul à la fois.

Ok merci beaucoup, je vais regarder ça.

Super, ça fonctionne! Une dernière question :
Comment faire pour que la fenêtre se rajuste en fonction du nombre de cartes (pour 25 cartes une petite fenêtre et une grande pour100) ? Merci pour tout.

la méthode pack() permet d'ajuster la taille du conteneur en fonction du contenu.

J'ai essayer avec pack sur ma jframe, mais en prend toujours la taille maximal (avec mes 100 cartes). En faisant pack() après l'affichage des 25 cartes, la taille du jpanel gardée est celle du jpanel1 à 100 cartes. Je ne comprends pas pourquoi.

heu, question bête : pourquoi tu ne modifie pas la taille de la fenêtre (ou du panel ) tout simplement?

En général on évite de redimensionner les fenêtres des applications via le code pour des raisons de design et des problèmes potentiels évidents (genre la fenêtre qui devient trop grande pour l'écran et ainsi de se suite).

Il est préférable d'inclure un JScrollPane à la fenêtre et de ne pas modifier la taille de celle ci.

Accessoirement dans ton cas (celui d'un jeu) je te conseille de plus partir sur l'utilisation d'un unique composant custom pour afficher l'intégralité de tes éléments plutôt que de te baser sur de multiples layouts,Composantsé & cie qui ne s'avèreront que moyennement adaptés à ce genre de cas.

Exemple pour un damier:

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
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
188
189
190
191
192
193
package java2d;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.Rectangle2D;
 
import javax.swing.JButton;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
 
public class ChessBoard extends JComponent {
 
    private int nbOfCellsX;
    private int nbOfCellsY;
    private int cellWidth;
    private int cellHeight;
    private Color lightCellBackground = Color.white;
    private Color darkCellBackground = Color.black;
 
    public ChessBoard(int nbOfCellsX, int nbOfCellsY, int cellWidth, int cellHeight) {
        super();
        this.nbOfCellsX = nbOfCellsX;
        this.nbOfCellsY = nbOfCellsY;
        this.cellWidth = cellWidth;
        this.cellHeight = cellHeight;
    }
 
    @Override
    public boolean isOpaque() {
        return true;
    }
 
    private void computePreferredSize() {
        int xLength = nbOfCellsX * cellWidth;
        int yLength = nbOfCellsY * cellHeight;
        Dimension oldSize = getPreferredSize();
        Dimension newSize = new Dimension(xLength, yLength);
        setPreferredSize(newSize);
        firePropertyChange("preferredSize", oldSize, newSize);
        revalidate();
        repaint();
    }
 
    @Override
    protected void paintComponent(Graphics g) {
 
        Rectangle2D rec = new Rectangle2D.Double(0, 0, cellWidth, cellHeight);
        for (int i = 0; i < nbOfCellsY; i++) {
            Graphics2D g2d = (Graphics2D) g.create();
            g2d.translate(0, i * cellHeight);
            for (int j = 0; j < nbOfCellsX; j++) {
                if ((i + j) % 2 == 0) {
                    g2d.setPaint(darkCellBackground);
                } else {
                    g2d.setPaint(lightCellBackground);
                }
                g2d.fill(rec);
                g2d.translate(cellWidth, 0);
            }
        }
 
        super.paintComponent(g);
    }
 
    /**
     * @return the nbOfCellsX
     */
    public int getNbOfCellsX() {
        return nbOfCellsX;
    }
 
    /**
     * @param nbOfCellsX
     *            the nbOfCellsX to set
     */
    public void setNbOfCellsX(int nbOfCellsX) {
        this.nbOfCellsX = nbOfCellsX;
        computePreferredSize();
    }
 
    /**
     * @return the nbOfCellsY
     */
    public int getNbOfCellsY() {
        return nbOfCellsY;
    }
 
    /**
     * @param nbOfCellsY
     *            the nbOfCellsY to set
     */
    public void setNbOfCellsY(int nbOfCellsY) {
        this.nbOfCellsY = nbOfCellsY;
        computePreferredSize();
    }
 
    /**
     * @return the cellWidth
     */
    public int getCellWidth() {
        return cellWidth;
    }
 
    /**
     * @param cellWidth
     *            the cellWidth to set
     */
    public void setCellWidth(int cellWidth) {
        this.cellWidth = cellWidth;
        computePreferredSize();
    }
 
    /**
     * @return the cellHeight
     */
    public int getCellHeight() {
        return cellHeight;
    }
 
    /**
     * @param cellHeight
     *            the cellHeight to set
     */
    public void setCellHeight(int cellHeight) {
        this.cellHeight = cellHeight;
        computePreferredSize();
    }
 
    /**
     * @return the lightCellBackground
     */
    public Color getLightCellBackground() {
        return lightCellBackground;
    }
 
    /**
     * @param lightCellBackground
     *            the lightCellBackground to set
     */
    public void setLightCellBackground(Color lightCellBackground) {
        this.lightCellBackground = lightCellBackground;
        repaint();
    }
 
    /**
     * @return the darkCellBackground
     */
    public Color getDarkCellBackground() {
        return darkCellBackground;
    }
 
    /**
     * @param darkCellBackground
     *            the darkCellBackground to set
     */
    public void setDarkCellBackground(Color darkCellBackground) {
        this.darkCellBackground = darkCellBackground;
        repaint();
    }
 
    /**
     * @param args
     */
    public static void main(String[] args) {
        // TODO Auto-generated method stub
 
        JFrame f = new JFrame();
        final ChessBoard b = new ChessBoard(10, 10, 30, 30);
        JScrollPane p = new JScrollPane(b);
        f.add(p);
        JButton button = new JButton("Change number");
        button.addActionListener(new ActionListener() {
 
            @Override
            public void actionPerformed(ActionEvent e) {
                b.setNbOfCellsX(b.getNbOfCellsX() + 2);
                b.setNbOfCellsY(b.getNbOfCellsY() + 2);
            }
        });
        f.add(button, BorderLayout.SOUTH);
        f.setSize(600, 400);
        f.setLocationRelativeTo(null);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);
    }
 
}

Ok, merci Sinok je vais utiliser cette solution.