objet forme dynamique

**frto0** · 23/04/2010, 19h53

Bonjour,

Je viens de me mettre au java (plus l'habitude de de delphi et vb).
Je tentes de faire des applications similaire à mes précédentes.

Sur une interface graphique, je veux dessiner des formes géométriques (rectangle - cercle - arc de disque - triangle...) dont je pourrais par la suite changer l'état (visible - couleur...) et si possible par des fonction communes FindComponent.SetColor.

J'ai bien trouver des pistes :
- Dériver Shape
- Dessiner chaque élément dans un canvas

Ne voulant pas partir tête baissée, ce qui me ferais avoir un code spécifique pour un final commun, je me permet de vous demander de m'aiguiller.

FRED

**slim_java** · 24/04/2010, 01h52

salut
pour avoir une idée sur le dessin 2D en java tu peux consulter ce tuto et la FAQ sans oublier JavaFX qui a été concu pour t pour faire des applications ayant un GUI très graphique et fortement animé.

**frto0** · 25/04/2010, 19h12

Bonjour,

Je voudrait suite aux conseil de Slim voir JavaFX j'ai donc installé les plugins sous eclipse europa et je n'arrive pas à faire un nouveau script (erreur d'installation...). J'ai suivi le site :
http://www.vogella.de/articles/JavaFX/article.html

FRED

**bouye** · 25/04/2010, 22h00

Je n'utilise que NetBeans donc je ne sais rien de la mise en oeuvre de JFX dans Eclipse.

Repose cette dernière question dans le forum JavaFX (http://www.developpez.net/forums/f11...s-java/javafx/), il est possible que qqun utilise Eclipse.

**sinok** · 26/04/2010, 14h38

Si tu tentes une partie pure Swing voici les pistes:

En Swing aucun besoin d'utiliser Canvas, un simple extends JComponent/JPanel (au choix, le premier étant transparent, le second opaque) avec une redéfinition de la méthode paintComponent suffira.

Pour ta gestion des formes je te conseille plutôt de passer par de la délagation/composition plutôt que par de la dérivation/héritage.

Exemple pour une classe forme:

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
238
 
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;
    }
 
}

Pour le composant permettant d'afficher des formes:

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);
    }
 
 
}

**frto0** · 26/04/2010, 18h40

Merci sinok pour ton aide.

J'ai bien réussi à lancer le prg et à peut près compris.

Si je ne me trompe pas, on rattache à la fenêtre un tableau de Forme.

J'ai donc voulu créer une deuxiéme forme :

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
 
        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);
 
        Forme test2 =  new Forme(new Rectangle2D.Float(100, 100, 60, 50), true, Color.BLUE);
        test2.setOutlined(true);
        test2.setOutlinePaint(Color.black);
        test2.setTransform(AffineTransform.getRotateInstance(21, 3.01));
        c.addShape(test2);
 
 
        JFrame f = new JFrame();   
        f.add(c);

mais je n'est toujours que la première qui s'affiche. J'ai donc voulu créer un deuxième Whiteboard et associé l'un puis l'autre à la fenêtre et là rien ne s'affiche.

J'aurais donc besoin d'un peu d'explications

FRED

**sinok** · 26/04/2010, 19h50

En effet il y a un petit bug dans la classe Forme. Dans le code de la méthode draw, il se trouve à la fin la ligne

Code :

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

g.dispose();

.
En effet la variable g fait référence aux Graphics2D passés en paramètre, ce qui a pour effet de finaliser ces graphics, de fait plus rien ne sera dessiner dessus. Donc la seconde Shape passe à la trappe.

De fait il faut remplacer cette ligne par

Code :

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