Discussion :

[abdelilah]

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 :

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

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.

[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:

[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.

[sinok]

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.

[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

[abdelilah]

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 :

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
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 :

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
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é.