Rectangles multiples Jpanel

Version imprimable

Bonjour tout le monde

Est il possible de rajouter plusieurs rectangles sur un jpanel tout en pouvant les différencier en vue de les manipuler par la suite car avec la méthode g.fillRect(10,10,80,80); permet de rajouter des rectangle mais ne me permet pas de les faire mouvoir par la suite, si joint une image explicative avec un bout de code.
Code:

1 2 3 4 5 6 7 8 9 10 public void paint(Graphics g){ Color c = g.getColor(); //g.setColor(Color.RED); g.fillRect(10,10,80,80); g.setColor(Color.BLUE); //g.fillOval(150,50,80,80); /*g.fillRect(40,40,300,300); g.setColor(Color.GREEN);*/ g.setColor(c); }
Merci d'avance.

http://img710.imageshack.us/img710/2...tjavafinal.png

27/04/2010, 18h55
sinok

Bah tu stocke tes Rectangles dans une List quelconque, puis à chaque dessin tu parcoures la liste pour dessiner tous les rectangles.

Pour celà il te suffit de te baser sur les classes implémentant l'interface Shape et la classe Graphics2d (et ses méthodes draw(Shapes), fill(Shape s) )

Cf ce topic relativement récent ou j'explique un peu la chose avec des exemples de code:
28/04/2010, 14h01
HNoury

Pour ma part, j'utilise une list, puis un algo du genre :
du dernier tracé au premier tracé *:
si positions X et Y de la souris entre X, X+wX, Y, Y+wY du rectangle de la liste, sélectionner ce triangle
puis modifier taille, couleur, etc. dans la liste. (dans son instance de classe en fait)

Redessiner le tout.

*On suppose que les triangles visibles ont été dessinés après ceux en dessous, d'où cet ordre.
28/04/2010, 15h20
sinok

Citation:

Envoyé par HNoury

Pour ma part, j'utilise une list, puis un algo du genre :
du dernier tracé au premier tracé *:
si positions X et Y de la souris entre X, X+wX, Y, Y+wY du rectangle de la liste, sélectionner ce triangle
puis modifier taille, couleur, etc. dans la liste. (dans son instance de classe en fait)

Redessiner le tout.

*On suppose que les triangles visibles ont été dessinés après ceux en dessous, d'où cet ordre.

La classe shape contient déjà une méthode contains faisant amplement l'affaire. Pour les formes non prévues de base dans Java il suffit d'utiliser les classe GeneralPath ou Path2D(en java 6 pour cette dernière) qui implémentent l'interface Shape.
28/04/2010, 15h48
abdelilah

Tout d'abord merci pour vos réponses, je dois également ajouter des écouteurs en vue de manipuler ces rectangles pour être clair pour en faire une écluse, j'appuie sur un bouton et je peux ainsi déplacer le rectangle.
Merci d'avance :ccool:

Bonjour

J'ai bien essayé les deux classes sur le topic de sinok mais la compilation échoue en m'indiquant le code erreur "Cannot find symbol".

La classe Forme.java se compile sans problème aucun :

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
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
package java2d;
 
import java.awt.AlphaComposite;
import java.awt.BasicStroke;
import java.awt.Graphics2D;
import java.awt.Paint;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.geom.AffineTransform;
 
public class Forme {
 
    private Shape shape;
    private Paint backgroundPaint;
    private Stroke stroke;
    private Paint outlinePaint;
    private boolean filled=false;
    private boolean outlined;
    private boolean visible=true;
    private AffineTransform transform;
    private float opacity=1.0f;
    private int compositionRule= AlphaComposite.SRC_OVER;
 
 
    public Forme() {
        stroke = new BasicStroke(2.0f);
 
    }
 
 
    public Forme(Shape shape, boolean filled, Paint backgroundPaint) {
        this();
        this.filled = filled;
        this.shape = shape;
        this.backgroundPaint = backgroundPaint;
    }
 
 
    public void draw(Graphics2D g) {
        if(visible) {
            //On crée un contexte Graphique temporaire afin d'appliquer toutes les modifs qu'on veut sans avoir à les défaire par la suite
            Graphics2D g2d = (Graphics2D) g.create();
            //On définit la Stroke que les Graphics vont utiliser
            g2d.setStroke(stroke);
 
            //On applique l'éventuelle transformation affine
            if (transform != null) {
                g2d.setTransform(transform);
            }
 
            //On applique le composite si besoin est
            if(opacity != 1.0f) {
                g2d.setComposite(AlphaComposite.getInstance(compositionRule, opacity));
            }
            //Si la forme est remplie on dessine le fond.
            if (filled) {
                g2d.setPaint(backgroundPaint);
                //Draw Background paint
                g2d.fill(shape);
                if(outlined) {
                    g2d.setPaint(outlinePaint);
                    g2d.draw(shape);
                }
            } else {
                //On dessine la forme
                g2d.setPaint(backgroundPaint);
                g2d.draw(shape);
            }
            g2d.dispose();
        }
    }
 
 
    /**
     * @return the shape
     */
    public Shape getShape() {
        if (transform != null) {
            return transform.createTransformedShape(shape);
        }
        return shape;
    }
 
 
    /**
     * @param shape the shape to set
     */
    public void setShape(Shape shape) {
        this.shape = shape;
    }
 
 
    /**
     * @return the backgroundPaint
     */
    public Paint getBackgroundPaint() {
        return backgroundPaint;
    }
 
 
    /**
     * @param backgroundPaint the backgroundPaint to set
     */
    public void setBackgroundPaint(Paint backgroundPaint) {
        this.backgroundPaint = backgroundPaint;
    }
 
 
    /**
     * @return the stroke
     */
    public Stroke getStroke() {
        return stroke;
    }
 
 
    /**
     * @param stroke the stroke to set
     */
    public void setStroke(Stroke stroke) {
        this.stroke = stroke;
    }
 
 
    /**
     * @return the outlinePaint
     */
    public Paint getOutlinePaint() {
        return outlinePaint;
    }
 
 
    /**
     * @param outlinePaint the outlinePaint to set
     */
    public void setOutlinePaint(Paint outlinePaint) {
        this.outlinePaint = outlinePaint;
    }
 
 
    /**
     * @return the filled
     */
    public boolean isFilled() {
        return filled;
    }
 
 
    /**
     * @param filled the filled to set
     */
    public void setFilled(boolean filled) {
        this.filled = filled;
    }
 
 
    /**
     * @return the outlined
     */
    public boolean isOutlined() {
        return outlined;
    }
 
 
    /**
     * @param outlined the outlined to set
     */
    public void setOutlined(boolean outlined) {
        this.outlined = outlined;
    }
 
 
    /**
     * @return the visible
     */
    public boolean isVisible() {
        return visible;
    }
 
 
    /**
     * @param visible the visible to set
     */
    public void setVisible(boolean visible) {
        this.visible = visible;
    }
 
 
    /**
     * @return the transform
     */
    public AffineTransform getTransform() {
 
        return transform;
    }
 
 
    /**
     * @param transform the transform to set
     */
    public void setTransform(AffineTransform transform) {
        this.transform = transform;
    }
 
 
    /**
     * @return the opacity
     */
    public float getOpacity() {
        return opacity;
    }
 
 
    /**
     * @param opacity the opacity to set
     */
    public void setOpacity(float opacity) {
        this.opacity = opacity;
    }
 
 
    /**
     * @return the compositionRule
     */
    public int getCompositionRule() {
        return compositionRule;
    }
 
 
    /**
     * @param compositionRule the compositionRule to set
     */
    public void setCompositionRule(int compositionRule) {
        this.compositionRule = compositionRule;
    }
 
}

La classe Whiteboard.java ne se compile pas :

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
package java2d;
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.event.MouseEvent;
import java.awt.event.MouseListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;
import java.util.List;
 
import javax.swing.JComponent;
import javax.swing.JFrame;
 
public class Whiteboard extends JComponent implements MouseListener {
    private List<Forme> shapes;
 
    public Whiteboard() {
        this.addMouseListener(this);
        shapes = new ArrayList<Forme>();
    }
 
    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);
 
        Graphics2D g2d = (Graphics2D) g;
        g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        for (Forme myShape : shapes) {
            myShape.draw(g2d);
        }
    }
 
    @Override
    public void mouseClicked(MouseEvent arg0) {
        for (Forme myShape : shapes) {
            if (myShape.getShape().contains(arg0.getX(), arg0.getY())) {
                myShape.setFilled(!myShape.isFilled());
                repaint();
            }
        }
 
    }
 
    @Override
    public void mouseEntered(MouseEvent arg0) {
        // TODO Auto-generated method stub
 
    }
 
    @Override
    public void mouseExited(MouseEvent arg0) {
        // TODO Auto-generated method stub
 
    }
 
    @Override
    public void mousePressed(MouseEvent arg0) {
        // TODO Auto-generated method stub
 
    }
 
    @Override
    public void mouseReleased(MouseEvent arg0) {
        // TODO Auto-generated method stub
 
    }
 
    public void addShape(Forme myShape) {
        shapes.add(myShape);
    }
 
    public static void main(String[] args) {
        Whiteboard c = new Whiteboard();
        Forme test =  new Forme(new Rectangle2D.Float(20, 20, 60, 50), true, Color.RED);
        test.setOutlined(true);
        test.setOutlinePaint(Color.black);
        test.setTransform(AffineTransform.getRotateInstance(21, 3.01));
        c.addShape(test);
        JFrame f = new JFrame();
        f.add(c);
        f.setSize(400, 300);
        f.setLocationRelativeTo(null);
        f.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
        f.setVisible(true);
    }
 
 
}

Merci d'avance pour votre aide je suis vraiment coincé.

15/05/2010, 23h28
Caalador

Je pense qu'il te manque l'import pour l'objet Forme dans ton en-tête de class.
Il faut aussi retirer les @Override pour les méthodes du MouseListener.

Lorsque tu as des erreurs, il faut donner un peu plus d'infos aussi (message d'erreur, ligne de l'erreur, ...) car sinon on cherche un peu dans le noir !

D'abord merci pour ton aide, j'avoue que je n'ai même pas pensé à poster le message d'erreur (débutant que je suis :aie:), pour l'entête les deux classe se trouve dans le même dossier en principe il n'est pas nécessaire de l'importer et je peux me tromper, le cas échéant comment puis-je l'importer.

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
Whiteboard.java:18: cannot find symbol
symbol  : class Forme
location: class java2d.Whiteboard
    private List<Forme> shapes;
                 ^
Whiteboard.java:71: cannot find symbol
symbol  : class Forme
location: class java2d.Whiteboard
    public void addShape(Forme myShape) {
                         ^
Whiteboard.java:22: cannot find symbol
symbol  : class Forme
location: class java2d.Whiteboard
        shapes = new ArrayList<Forme>();
                               ^
Whiteboard.java:31: cannot find symbol
symbol  : class Forme
location: class java2d.Whiteboard
        for (Forme myShape : shapes) {
             ^
Whiteboard.java:38: cannot find symbol
symbol  : class Forme
location: class java2d.Whiteboard
        for (Forme myShape : shapes) {
             ^
Whiteboard.java:77: cannot find symbol
symbol  : class Forme
location: class java2d.Whiteboard
        Forme test =  new Forme(new Rectangle2D.Float(20, 20, 60, 50), true, Col
or.RED);
        ^
Whiteboard.java:77: cannot find symbol
symbol  : class Forme
location: class java2d.Whiteboard
        Forme test =  new Forme(new Rectangle2D.Float(20, 20, 60, 50), true, Col
or.RED);
                          ^
7 errors

Merci d'avance pour vos réponses.

16/05/2010, 00h26
Caalador

Non, en effet, comme tes class sont dans le même package pas besoin d'import.
J'ai recréé une structure identique à la tienne, avec des copier/coller de tes class.
Et à part les @override en trop, tout marche chez moi.

Enfin, j'ai une JFrame qui s'ouvre avec un rectange rouge incliné dedans, et qui réagit bien au listener.

Sinon, vu l'erreur, tu dois compiler à la main non ? As tu bien mis ton répertoire au ClassPath ?
16/05/2010, 03h38
abdelilah

Merci pour ta réponse, non je n'ai modifié en rien le classpath, je ne le modifie pas partant du fait que le tout se trouve dans le même dossier, que dois je faire ?
Merci d'avance.
16/05/2010, 11h05
Caalador

Tu as des infos ICI, en bas de la page.
16/05/2010, 11h59
abdelilah

Merci pour ta réponse, je vais la consulter tout de suite :mrgreen:
16/05/2010, 22h28
abdelilah

Bonsoir tout le monde

Je viens de trouver l'origine du problème 8-), c'est le package java2d qui n'a pas lieu d'être, une fois enlevé tout marche et j'obtiens le même résultat que Caalador, la première étape franchie, mais il me reste à finaliser ce que je voulais faire.