Discussion :

[Mockingbird]

Bonsoir,
J'ai une interface graphique en Swing dans laquelle je souhaite avoir deux JPanel superposés et pouvoir dessiner sur l'un sans que cela impacte l'autre...
Apparemment, ce n'est pas possible car le paint() redessine tout...
En gros, j'ai :
-JPanel1 : sur lequel je dessinerai une grille avec cases pleines ou pas
-JPanel2 : sur lequel je dessine des points et des vecteurs

J'aimerais que ce que je dessine sur le JPanel2 soit persistant, c'est à dire que ce soit jamais effacé, même si le JPanel1 est redessiné...
Je sais pas si c'est faisable en Swing... donc je voulais savoir si c'était judicieux de faire comme ça ....

Merci !

[Invité]

Le paint(Graphics G) ne va redessiner QUE dans son composant Graphics.

Parcontre la difficulté est de superposer 2 JPanel. Peut-être peux tu regarder du coté du CardLayout() qui permet justement de superposer des panneaux et d'en afficher en avant mais je ne sais pas vraiment se qu'il fait avec ceux qui sont derrière. Si il les garde afficher alors le fait de faire un :
jPanel1.setOpaque(false);

devrait te permettre de voir le jPanel2 derrière tout en pouvant dessiner sur le panel au premier plan.

[Mockingbird]

Bonjour,
Oui j'ai testé ça aussi, mais c'est pareil, c'est à dire on obtient le même comportement que si je superpose à la main les deux JPanel.
La transparence est bien là au début, c'est à dire si je met le panel du fond en jaune, et que je dessine par dessus avec l'autre, on voit bien le jaune derrière...mais si je veux repeindre le fond en mettant autre chose, et bien je perds ce qu'il y a devant...

[Invité]

A chaque fois que tu touches au JPanel de derriere il faut que tu fasses un repaint() de celui de devant alors.
Mais il y a peut etre mieux.

[Mockingbird]

Bonjour,
L'ennui c'est que ce que je dessine devant, j'en garde pas trace pour l'instant, c'est à dire que je ne peux pas faire de repaint()... c'est pour ça que je voulais un truc persistant en fait.. Par exemple sur le jpanel de devant, j'ai un graphe (plein de points reliés entre eux). Sur le panel du fond, j'ai une grille avec certaines cases allumés ou pas. J'utilisais justement la rémanence de l'affichage pour ne pas avoir à stocker quelque part le graphe...et éviter de devoir faire un réaffichage complet à partir d'un graphe stocké quelque part...
Merci

[Invité]

Tu peux poster du code stp ?

[Mockingbird]

Re bonjour et merci pour l'aide
J'ai essayé de rester le plus concis possible. Le code qui suit est dans une JFrame. Il y a des boutons qui permettent d'enclencher telles ou telles actions.

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
 
Deux jpanel :
JPanelDrawingArea (pour afficher points et liaisons entre eux)
JPanelDrawingGrilleRessource (pour afficher la grille et les cases allumé)
 
 
private void jButtonAfficherGrilleActionPerformed(java.awt.event.ActionEvent evt) {                                                      
        this.afficherCaseAllume();
         this.afficherGrille();
 
    }                                                     
 
 
 
    private void jButtonActionActionPerformed(java.awt.event.ActionEvent evt) {                                              
        // TODO add your handling code here:
 
	// Code métier qui utilise drawVector et drawOval pour dessiner des points
	// et les relier entre eux. Une fois qu'ils sont dessinés, leur position 
	// est pour l'instant perdue
 
 
    }                                             
 
 
 
    private void drawVector(Position pdeb, Position pfin) {
        if (pdeb != null && pfin != null) {
 
            jPanelDrawingArea.getGraphics().drawLine(pdeb.getJ() * 10 + 5, 10 * pdeb.getI() + 5,
                    10 * pfin.getJ() + 5, 10 * pfin.getI() + 5);
        }
    }
 
    private void drawOval(Position p, Color c) {
        int i = p.getI();
        int j = p.getJ();
        Double dd = Math.sqrt(2) * 4;
        int d = dd.intValue();
        Graphics g = jPanelDrawingArea.getGraphics();
        g.setColor(c);
        g.fillOval(10 * j + 3, 10 * i + 3, d, d);
    }
 
    private void drawCasePleine(int i, int j, Color c) {
        Double dd = Math.sqrt(2) * 2;
        int d = dd.intValue();
        Graphics g = jPanelDrawingGrilleRessource.getGraphics();
        g.setColor(c);
 
        g.fillRect(10 * j, 10 * i, 10, 10);
 
    }
 
 
    private void afficherGrille() {
      // Utilisation d'une double boucle for avec drawRect pour afficher
      // une grille. On dessine sur le JPanelDrawingGrilleRessource
    }
 
 
    private void afficherCaseAllume() {
	// Code métier qui parcourt la liste des cases allumés, et qui les 
	// dessine (ou pas) suivant leur valeur. La liste provient du modèle
	// qui est mis à jour à chaque action. On dessine sur le  // JPanelDrawingGrilleRessource
 
 
    }

Rien ne vaut une image pour expliquer :
http://www.hiboox.fr/go/images/infor...04ee0644c3.gif

Ce qui se passe en fait, c'est que les cases peuvent changer de couleur, or quand elles le font, elles effacent le chemin dessiné par les points...

En fait je me rends compte qu'il faut que j'envois plus d'information depuis le modèle vers la vue/contrôleur... et que j'affine un peu. Car pour l'instant dans la méthode jButtonActionActionPerformed, ce que je faisais, c'était juste récupérer deux points d'une liste généré par le modèle, les afficher et dessiner une ligne entre eux.

[Invité]

C'est marrant comme image je me demande bien ce que tu fais avec ca ^^

Sinon je ne pense pas que 2 panels superposés soit la solution. Le mieux est d'utiliser un panel de dessin dans lequel tu surcharges ta méthode paint(Graphics g).

Dans cette dernière tu traces ta grille, puis tu traces les couleurs de tes cases selon ton algo et enfin tu traces les points et les lignes que tu as calculés.

Ce qui veut dire que tu dois forcément enregistrer les coordonnées de tes points.

J'ai fait une petite applet de retouche d'image et j'utilise ce principe.

dans la méthode paint je peins mon image puis je parcours un tableau qui contient les actions de l'utilisateur et pour chaque action (qui est représenté par une classe spécifique) j'appelle la méthode draw de mon action en passant en parametre le "Graphics" de mon panel.

A chaque fois que l'utilisateur trace quelque chose, les coordonnées sont enregistré dans un objet, l'objet est ajouté à la liste des retouches et je repaint mon panel.

[Mockingbird]

En fait c'est une sorte de fourmilière. Pour l'instant il y a juste des mouvements aléatoires.
Sinon, je m'en suis sorti en définissant la vue graphique comme un observateur de mon modèle. Et à chaque fois, dans le modèle, que je fais une affectation d'une valeur sur la matrice, j'envoie l'information (coordonnées et couleur de la case) à tous les observateurs qui eux font le traitement approprié, à savoir le dessin de la case si besoin (ou effacement). Et ca marche en fait, c'est beaucoup plus "fin" comme programmation. Les affectations étant appelées par plusieurs méthodes, la réactualisation se fait bien et j'ai toujours la trace par dessus avec mon ancien code. J'ai quand même gardé deux JPanel pour ça...Mais c'est plus rapide je pense que de toute réactualiser en lisant à partir d'un truc qui grandirait trop de toute façon.
Merci pour les conseils Mr_LoOnY