Discussion :

[Gabounet]

Bonjour,

J'essaye de faire un hexagone et ensuite de mettre cet hexagone dans une fenêtre. Pour l'instant j'arrive à l'ajouter à la frame mais si je veux l'ajouter à la frame via un JPanel il me sort une toute petite image avec un hexagone pas fini à l'intérieur.

J'oublie peut-être une commande. J'ai essayer en réglant la taille de mon panel mais ça ne change rien.

Je vous met mon code ci-dessous. Si vous voulez plus de renseignements merci de me le faire savoir et merci pour votre aide.

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
package hex;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.LayoutManager;
import java.awt.event.MouseEvent;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
 
public class Hex {
 
 
    JFrame frame = new JFrame();
    JPanel hexagonePanel = new JPanel();
    Hexagone hexagone;
    boolean redBlue = false;
 
    public Hex() {
 
        hexagone = new Hexagone();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(700, 450);
        hexagonePanel.add(hexagone);
        frame.add(hexagonePanel);
        frame.setVisible(true);
 
    }
 
    public static void main(String[] args) {
 
        Hex hex = new Hex();
 
    }

[Mathieu.J]

Poste ta classe Hexagone avec une description.
Tu devrais utiliser des layout sur ta frame et ton panel.

[Gabounet]

Oui je compte mettre des layout quand j'aurais réussi à faire ça.

Voici ma classe Hexagone:

Je crée un hexagone non rempli puis un autre rempli pour qu'il soit de la couleur que je veux mais toujours avec des contours noir tout simplement.

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
 
package hex;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import javax.swing.JPanel;
 
/**
 *
 * @author Gabou
 */
public class Hexagone extends JPanel {
 
 
    private int xHex[] = {0, 16, 32,32,16,0};
    private int yHex[] = {10,0,10,30,40,30};
 
    private int xHexInt[] = {1, 16, 31,31,16,1};
    private int yHexInt[] = {10,1,10,30,39,30};
 
    private Color couleur = Color.WHITE;
    public Hexagone(){
 
    }
 
    @Override
        public void paintComponent(Graphics g) {
 
        Graphics2D g2d = (Graphics2D)g;
        RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setRenderingHints(hints);
 
        g2d.drawPolygon(xHex, yHex, 6);
        g2d.setColor(couleur);
        g2d.fillPolygon(xHexInt, yHexInt, 6);
 
        }
 
    public Color getCouleur() {
        return couleur;
    }
 
    public void setCouleur(Color couleur) {
        this.couleur = couleur;
    }
 
 
}

[Mathieu.J]

Avec des Layout ça marche mieux. Le layout par défaut est FlowLayout. Avec ce layout les composants ne s'agrandissent pas pour prendre toute la place. Du coup ton panel était tout petit (width=10, height=10 sur mon poste).

Un peu de doc :
http://docs.oracle.com/javase/tutori...ut/visual.html
http://docs.oracle.com/javase/tutori...out/using.html

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
package hex;
 
import java.awt.BorderLayout;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
 
public class Hex {
 
 
    JFrame frame;
    JPanel hexagonePanel;
    Hexagone hexagone;
    boolean redBlue = false;
 
    public Hex() {
 
        hexagone = new Hexagone();
        frame = new JFrame();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(700, 450);
        hexagonePanel = new JPanel();
        hexagonePanel.setLayout(new BorderLayout());
        hexagonePanel.add(hexagone, BorderLayout.CENTER);
        frame.setLayout(new BorderLayout());
        frame.add(hexagonePanel, BorderLayout.CENTER);
        frame.setVisible(true);
 
    }
 
    public static void main(String[] args) {
         Hex hex = new Hex();
    }
}

Au passage, si ton hexagone est déjà un JPanel, pas besoin de le placer dans un JPanel intermédiaire.

[Gabounet]

Ah ouais j'arrive à afficher mon hexagone dedans.

En fait le but final serait de faire plusieurs hexagone côte à côte (http://upload.wikimedia.org/wikipedi...oard_11x11.svg) que je puisse mettre dans un panel (c'est pour ça que j'essaye de mettre un panel dans un panel).

Je réfléchi là-dessus et je poste ce soir pour dire si j'ai trouvé ou pas.

Merci pour ton aide.

PS: Peut-on utiliser des setBounds avec des layouts?

[sinok]

Pour faire simple, tu crées un composant héritant de JComponent, tu redéfinis la méthode protected paintComponent, et tu dessines sur les graphics fournis en paramètre de cette méthode tous tes hexagones.

La version avec un composant par hexagone n'est pas tenable, chiante en terme de maintenance... Bref, aucun intérêt à celle ci.

Alors qu'avec un seul composant, ce sera amplement plus simple.

Tu te fais une classe servant de modèle (position & statut des différent hexagones), et tu t'appuies sur ce modèle dans ta classe héritant de JComponent pour réaliser les opérations de dessin dans le paintComponent

[Gabounet]

Je vais essayer ça, c'est vrai que créer une instance d'hexagone peut-être assez lourd. Cela peut-il grandement influer sur les ressources nécessaires pour faire tourner une application?

Sinon je voulais modifier les caractéristiques d'un des hexagones (la couleur par exemple) après une action de l'utilisateur. C'est pour ça que j'avais pensé à créer plusieurs instances car faire un repaint va me redessiner tous les hexagones, c'est peut-être un peu lourd non? (ou alors j'ai pas bien compris le fonctionnement de paintcomposant :p)



Enfin merci pour vos réponses rapide, je vous tiens au courant de mon avancée.

[tchize_]

Non, le problème c'est de faire des classes Hexagone qui soient des composants graphique. Ce n'est pas facilement tenable. Il va falloir chipoter avec les masques de Graphics pour qu'un hexagone n'efface pas son voisin, chipoter avec un layoutmanager personnalisé qui positionne sur une grille hexa, bref la gloire.

La suggestion est de faire un composant "Panneau de jeu" ou que sais-je, qui dessinne elle même les hexagones directement. Après tu lui file des objets hexagone, qui ne sont que des données, à afficher

[Gabounet]

J'ai un peu du mal à comprendre. Comment on affiche des données qui ne sont pas des composants graphiques?

A chaque fois que je fait un paintComponant je le met dans un conteneur. Ensuite si je veux modifier tout ou partie de mon dessin je redessine entièrement le paintComponant.

Par exemple, on a un carré divisé en 4, si je veux une des partie en rouge quand je clique dessus, je vais faire appelle à la méthode repaint() qui va me redessiner tout mon carré.

Peut-être ai-je mal compris le fonctionnement ou alors je m'en sers de la mauvaise manière?

Je vais vous mettre le code entier de mon programme que j'avais fais pour que vous compreniez mieux ce que j'essaie de faire et ce que je ne comprends pas .

(Je n'ai pas utilisé de layout quand j'ai commencé mon programme)

En premier la classe qui crée un hexagone.

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
 
package hex;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import javax.swing.JPanel;
 
/**
 *
 * @author Gabou
 */
public class Hexagone extends JPanel {
 
 
    private int xHex[] = {0, 16, 32,32,16,0};
    private int yHex[] = {10,0,10,30,40,30};
 
    private int xHexInt[] = {1, 16, 31,31,16,1};
    private int yHexInt[] = {10,1,10,30,39,30};
 
    private Color couleur = Color.WHITE;
    public Hexagone(){
 
    }
 
    @Override
        public void paintComponent(Graphics g) {
 
        Graphics2D g2d = (Graphics2D)g;
        RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setRenderingHints(hints);
        g2d.drawPolygon(xHex, yHex, 6);
        g2d.setColor(couleur);
        g2d.fillPolygon(xHexInt, yHexInt, 6);
 
        }
 
    public Color getCouleur() {
        return couleur;
    }
 
    public void setCouleur(Color couleur) {
        this.couleur = couleur;
    }
 
 
}

Ensuite la classe qui crée mon plateau et qui lance le programme. (Il y a un peu de bidouille concernant les affichages notamment au niveau de la dernière ligne car elle affiche le dernier hexagone au début je l'ai donc rendu invisible.

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
 
package hex;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.LayoutManager;
import java.awt.event.MouseEvent;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class Hex {
 
    JFrame frame = new JFrame();
    JPanel hexagonePanel = new JPanel();
    JPanel hexagonePanel2 = new JPanel();
    Hexagone[][] tabHexaPanel = new Hexagone[14][13];
    Hexagone hexagone;
    boolean redBlue = false;
 
    public Hex() {
 
        hexagone = new Hexagone();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(700, 450);
 
        for (int i = 0; i < 14; i++) {
 
            for (int j = 0; j < 13; j++) {
 
                tabHexaPanel[i][j] = new Hexagone();
                tabHexaPanel[i][j].setBounds(j * 32 + i * 16, i * 30, 33, 41);
                tabHexaPanel[i][j].setOpaque(false);
                frame.add(tabHexaPanel[i][j]);
                System.out.println(hexagonePanel.getBounds());
                tabHexaPanel[i][j].setName(i + "," + j);
                tabHexaPanel[i][j].addMouseListener(new java.awt.event.MouseAdapter() {
 
                    @Override
                    public void mousePressed(java.awt.event.MouseEvent evt) {
                        hexagoneMousePressed(evt);
                    }
 
                    @Override
                    public void mouseReleased(java.awt.event.MouseEvent evt) {
                        hexagoneMouseReleased(evt);
                    }
                });
                if (i == 13) {
                    tabHexaPanel[i][j].setVisible(false);
                }
                else if(i == 12 || i == 0) {
                    tabHexaPanel[i][j].setCouleur(Color.red);
                }
                else if(j == 12 || j == 0) {
                    tabHexaPanel[i][j].setCouleur(Color.blue);
                }
 
            }
 
        }
 
        frame.setVisible(true);
 
    }
 
    public static void main(String[] args) {
 
        Hex hex = new Hex();
 
 
 
    }
 
    public void hexagoneMousePressed(MouseEvent e) {
        System.out.println(e.getComponent().getName());
 
        String[] str = e.getComponent().getName().split(",");
 
        if (e.getButton() == 1 && tabHexaPanel[Integer.parseInt(str[0])][Integer.parseInt(str[1])].getCouleur() == Color.white) {
            if (!redBlue) {
                tabHexaPanel[Integer.parseInt(str[0])][Integer.parseInt(str[1])].setCouleur(Color.blue);
                redBlue = !redBlue;
            } else {
                tabHexaPanel[Integer.parseInt(str[0])][Integer.parseInt(str[1])].setCouleur(Color.red);
                redBlue = !redBlue;
            }
        } else if (e.getButton() == 2) {
            tabHexaPanel[Integer.parseInt(str[0])][Integer.parseInt(str[1])].setCouleur(Color.white);
            redBlue = !redBlue;
        }
 
 
        System.out.println(tabHexaPanel[Integer.parseInt(str[0])][Integer.parseInt(str[1])].getCouleur());
        tabHexaPanel[Integer.parseInt(str[0])][Integer.parseInt(str[1])].repaint();
 
 
    }
 
    public void hexagoneMouseReleased(MouseEvent e) {
    }
}

[tchize_]

De la même manière que quand tu as une JCombobox, il n'y a pas un composant par élément de la combobox.

Ton éléménet graphique c'est ton panneau. Dans son paint component, il parcoure ses données pour savoir combien il a d'hexagones, de quelle couleur ils sont, si il y a des éléments dessus, etc. Bref, tu as un composant "surface hexagonale", chargée de dessiner tes données, et tu as un ensemble de données.

Il y a toujours dans ton application d'un coté les données, de l'autre les composant qui les affichent. On te recommande de regrouper toutes tes données "hexagone" en demandant à un seul composant "surface hexagonale" de le dessiner.

Pour prendre un autre exemple. Imaginons un jeu d'échec. Tu va avoir un unique composant graphique "échiquier" et tu va avoir des données, par exemple:
- un tableau de 8x8 ou chaque entrée est null ou a le nom+couleur d'une pièce d'échec.
- un flag disant si oui ou non on veux afficher les coordonnées
- éventuellement une valeur permettant de savoir dans quel style sont les pièce si tu as plusieurs dessins possible
- etc

[Gabounet]

Ça me fait un peu mal à la tête tout ça.
A tout les coups il doit y avoir quelque chose qui m'échappe pour avoir le déclic.

D'après ce que je comprends:

- Je fais un composant qui hérite de JComponant
- Je redéfinis paintComponent pour dessiner mes hexagones.
- A côté je regroupe les informations de mes hexagones dans un tableau par exemple.

[tchize_]

oui, par exemple


ensuite dans ton painComponent, tu aura un truc du style

pour chaque hexagone dans la région à redessiner:

dessiner un polygone de 6 cotés, aux coordonées de l'hexagone, avec un couleur apprpriée à l'état de l'hexagone

et une méthode genre changerHexagone(x,y,nouvelleValeur) qui fera:

• stocker la nouvelle valeur
• déterminer le rectangle entourant l'hexagone
• appeler repaint(leRectangleEnQuestion)

[Gabounet]

Je pense que je vois mieux ce que tu dis mais si je veux modifier un des hexagones en cliquant dessus je peux pas savoir sur lequel j'ai cliqué. Si?

Et si je choisi une zone ça ne sera pas très précis.

[tchize_]

Ben ton composant va recevoir un évènement de click avec des coordonnées, ça doit pas être bien dur de déterminer à quel hexagone appartiennent ces coordonnées

[Gabounet]

Oui c'est ce que je comptais faire mais c'est plus simple avec des carrés qu'avec des hexagones mais je vais essayer.

En tout cas merci pour votre aide et votre patience

Je vous dirais si j'ai réussi ou pas.

[Gabounet]

J'ai réussi à faire quelque chose qui me semble être ce qu'il fallait faire. Je vous met le code:

Cette première classe crée tout les hexagones et les colore.

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
 
package hex;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import javax.swing.JComponent;
 
/**
 *
 * @author Gabriel
 */
public class Hexagones extends JComponent {
 
    private int xHex[] = {0, 16, 32, 32, 16, 0};
    private int yHex[] = {10, 0, 10, 30, 40, 30};
    private int xHex2[] = new int[6];
    private int xHexInt2[] = new int[6];
    private int xHexInt[] = {1, 16, 31, 31, 16, 1};
    private int yHexInt[] = {10, 1, 10, 30, 39, 30};
    private int yHex2[] = new int[6];
    private int yHexInt2[] = new int[6];
    private Hexagone hexagone = new Hexagone();
    private Color[][] couleur = new Color[11][11];
    private boolean firstTime = true;
 
    public Hexagones() {
 
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                couleur[i][j] = Color.WHITE;
            }
        }
 
    }
 
    @Override
    public void paintComponent(Graphics g) {
 
 
        Graphics2D g2d = (Graphics2D) g;
        RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        g2d.setRenderingHints(hints);
        for (int i = 0; i < 11; i++) {
 
            for (int k = 0; k < xHex.length; k++) {
                yHex2[k] = yHex[k] + i * 30;
                yHexInt2[k] = yHexInt[k] + i * 30;
 
            }
            for (int j = 0; j < 11; j++) {
 
                for (int k = 0; k < xHex.length; k++) {
                    xHex2[k] = xHex[k] + j * 32 + i * 16;
                    xHexInt2[k] = xHexInt[k] + j * 32 + i * 16;
                }
                g2d.setColor(Color.black);
                g2d.drawPolygon(xHex2, yHex2, 6);
                g2d.setColor(couleur[i][j]);
                g2d.fillPolygon(xHexInt2, yHexInt2, 6);
            }
 
        }
    }
 
    public void changerHexagone(int i, int j, Color couleur) {
        this.couleur[i][j] = couleur;
        repaint();
    }
}

Cette classe là, affiche mes hexagones et permet de changer la couleur d'un des hexagones en cliquant dessus.

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
 
package hex;
 
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.MouseEvent;
import javax.swing.JFrame;
import javax.swing.JPanel;
 
public class Hex {
 
    JFrame frame = new JFrame();
    JPanel hexagonePanel = new JPanel();
    JPanel hexagonePanel2 = new JPanel();
    Hexagone[][] tabHexaPanel = new Hexagone[14][13];
    Hexagones hexagone;
    boolean redBlue = false;
 
    public Hex() {
 
        hexagone = new Hexagones();
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setSize(700, 450);
        hexagonePanel.addMouseListener(new java.awt.event.MouseAdapter() {
 
            @Override
            public void mousePressed(java.awt.event.MouseEvent evt) {
                hexagoneMousePressed(evt);
            }
 
            @Override
            public void mouseReleased(java.awt.event.MouseEvent evt) {
                hexagoneMouseReleased(evt);
            }
        });
        hexagonePanel.setLayout(new BorderLayout());
        hexagonePanel.add(hexagone, BorderLayout.CENTER);
        frame.setLayout(new BorderLayout());
        frame.add(hexagonePanel, BorderLayout.CENTER);
        frame.setVisible(true);
 
    }
 
    public static void main(String[] args) {
 
        Hex hex = new Hex();
 
 
 
    }
 
    public void hexagoneMousePressed(MouseEvent e) {
        System.out.println(e.getPoint());
 
        for (int i = 0; i < 11; i++) {
            for (int j = 0; j < 11; j++) {
                if ((e.getY() - i * 30) > (-5 / 8) * (e.getX() - j * 32 - i * 16) + 10 && (e.getY() - i * 30) > (5 / 8) * (e.getX() - j * 32 - i * 16) - 10 && (e.getY() - i * 30) < (-5 / 8) * (e.getX() - j * 32 - i * 16) + 50 && (e.getY() - i * 30) < (-5 / 8) * (e.getX() - j * 32 - i * 16) + 30 && (e.getX() - j * 32 - i * 16) < 32 && (e.getX() - j * 32 - i * 16) > 0) {
                    System.out.println("coucou");
                    hexagone.changerHexagone(i, j, Color.blue);
                }
            }
        }
    }
 
    public void hexagoneMouseReleased(MouseEvent e) {
    }
}

Qu'est-ce que vous en pensez? Est-ce que cela suit bien vos recommandations?
Le fait de redessiner tout les hexagones prend-il beaucoup de ressources?
Peut-on redessiner juste une partie du paintcomponent?

Merci pour vos réponses

[tchize_]

on pourrait encore améliorer en tenant compte du clipRect présent dans le graphic, ce clipRect permet de savoir quelle est la zone à redessiner (tout ce que tu dessine en dehors est dessiné en vain, il n'apparait pas a l'écran). L'usage typique: si un petite fenetre passe au dessus de ta fenetre, on ne redessine que les partie qui ont été caché pour rendues à nouveau visible par la fenêtre du dessus.

Pour ce qui est du changement de couleur et de la gestion des évènements, il existe une méthode repain(Rectangle) qui permet de ne redessiner qu'une partie.

[Gabounet]

Je comprends pas l’intérêt d'utiliser un cliprect.
Je pense avoir saisi son fonctionnement: je lui défini une zone et il ne dessinera pas ce qu'il y a en dehors.
Mais je vois pas quelle utilisation en faire dans mon programme.

[tchize_]

Bien quand on clique sur un hexagone pour le changer de couleur, a priori, il n'y a que cet heaxagone à redessiner d'ou l'intérer de faire un repaint(Rectangle) entourant cet hexagone. Les opération de dessin, ça prend du temps, inutile de redessiner toute une grille de 2500 hexagones quand on peux se contenter de n'en redissiner que 7 Et swing t'aide beaucoup avec les clipRect en t'informant sur la zone qu'il a besoin que tu redessine (parce que il n'y a par exemple qu'un petit carré à redessiné où un popup était passée au dessus, par exemple.

[Gabounet]

Donc si j'ai bien compris en plus de faire un : repaint(x,y,width,height);
je fais un g2d.clipRect(x, y, width,height); ?

Mais ces deux méthodes ne font pas la même chose?