Discussion :

[jlassiramzy]

salut,

serait il possible avec swing de dessiner ce composant qui servira comme indicateur pour des données aéronautiques ... quelqu'un peut il me donner un coup de main svp ?

merci

[Sebou77]

Le mieux ça serait pas de faire une image du cadran, plusieur images de fleches suivant plusieur position, et les déplacer en fonction de tes données ?
Parce que dessiner ça en swing ça va être violent

[sinok]

Déja tu vas commencer par modéliser ton composant au niveau code, c'est à dire un model contenant les diverses informations de base, cad les diverses valeurs qui seront affichée (et donc les setters qui vont bien).

La deuxième chose à faire est de décomposer les divers éléments dont tu auras besoin.

Donc grosso merdo:

• Une courbe et se graduations. => drawCurve et drawLine (utilisatiion de (co)sinus pour calculer l'inclinaison en fonction de ta courbe) sur les Graphics de ton composants
• Une flèche (probablement une image que sur laquelle tu devras effectuer une rotation) récupération des graphics de ton image, rotation en fonction de la valeur puis drawImage sur ton composant
• Les cadran de gauche et du bas sont composés de deux éléments: un rectangle et une String (drawRectangle et drawString sur les graphics de ton composant)
• Pas mal d'huile de coude.

Pour simplifier la chose au départ je te recommande de faire une graduation simple, c'est à dire droite au lieu de courbe

Pour aérer ton code essaye de découper les différents dessins en plusieurs méthodes du genre

Code :

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

drawArrow(Graphics g)

& cie

Bonne chance et bienvenu dans le monde de java2D

[jlassiramzy]

merci sinok mais je t'avoue que c'est encore du chinosi pour moi ..pourrais tu illustrer ce que tu as dit par un petit code qui pourra me servir de base ...je t'avoue que c'est un peu bloquant pour moi
et encore merci

[sinok]

On va dire que faire un code de base ne serait pas forcément très rapide, puis là je suis au taf, donc pas forcément le bon endroit pour le faire... Ce soir peut être

En attendant commences par te former de base sur le dessin en java: http://duj.developpez.com/tutoriels/java/dessin/intro/

Et à lire les tutos java2D de Sun:
http://java.sun.com/docs/books/tutorial/2d/TOC.html

Ainsi que la javadoc des classes Graphics et Graphics2D

[sinok]

Bon pour te donner une première idée de la modélisation (pas trop envie de me plonger la tête dans les maths ce soir, en ce moment en général)

Voilà ce que ça donne

Le modèle:

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
 
 
import javax.swing.event.EventListenerList;
 
 
public class GraduationModel {
 
    private EventListenerList listeners;
 
    private int value;
 
 
 
    public GraduationModel() {
        super();
        this.listeners = new EventListenerList();
    }
 
    public int getValue() {
        return value;
    }
 
    public void setValue(int value) {
        int oldValue = this.value;
        this.value = value;
        fireValueChanged(oldValue,value);
    }
 
 
    protected void fireValueChanged(int oldValue, int newValue) {
        GraduationEvent event = null;
 
        for(GraduationListener listener : getValueListeners()) {
            if(event == null)
                event = new GraduationEvent(oldValue, newValue);
            listener.valueChanged(event);
        }
 
    }
 
    public GraduationListener[] getValueListeners() {
        // TODO Auto-generated method stub
        return listeners.getListeners(GraduationListener.class);
    }
 
    public void addGraduateListener(GraduationListener l) {
        listeners.add(GraduationListener.class, l);
    }
 
}

Le listener et l'event associé:

Code :

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

1
2
3
4
5
6
7
8
9
 
 
import java.util.EventListener;
 
 
public interface GraduationListener extends EventListener{
 
    public void valueChanged(GraduationEvent e);
}

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
 
 
 
/**
 * @author sinok
 *
 */
public class GraduationEvent {
    private int oldValue;
    private int newValue;
 
    /**
     * @param oldValue
     * @param newValue
     */
    GraduationEvent(int oldValue, int newValue) {
        this.oldValue = oldValue;
        this.newValue = newValue;
    }
 
    /**
     * @return
     */
    public int getOldValue() {
        return oldValue;
    }
 
    /**
     * @return
     */
    public int getNewValue() {
        return newValue;
    }
}

Le composant faisant le dessin

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
 
 
import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.geom.Line2D;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferedImage;
import java.io.IOException;
 
import javax.imageio.ImageIO;
import javax.swing.JComponent;
import javax.swing.JFrame;
import javax.swing.Timer;
 
 
public class GraduationComponent extends JComponent implements GraduationListener, ActionListener{
    private GraduationModel model;
    private int oldValue;
    private int newValue;
    private int direction;
    private Timer timer;
    private BufferedImage thumb;
 
    public GraduationModel getModel() {
        return model;
    }
 
    public void setModel(GraduationModel model) {
        this.model = model;
    }
 
    public GraduationComponent(GraduationModel model) {
        super();
        this.model = model;
        this.timer = new Timer(50,this);
        model.addGraduateListener(this);
        try {
            thumb = ImageIO.read(getClass().getResourceAsStream("arrow.png"));
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
 
    }
 
    @Override
    protected void paintComponent(Graphics g) {
        // TODO Auto-generated method stub
        //super.paintComponent(g);
        Graphics2D g2d = (Graphics2D) g;
        if( this.isShowing()) {
            drawBackground(g2d);
            drawGraduate(g2d);
        }
    }
 
    public void valueChanged(GraduationEvent e) {
        // TODO Auto-generated method stub
        this.oldValue = e.getOldValue();
        this.newValue = e.getNewValue();
        if(oldValue > newValue) {
            direction = -1;
        } else if(oldValue < newValue) {
            direction = 1;
        } else {
            direction = 0;
        }
        timer.start();
    }
 
    public void actionPerformed(ActionEvent e) {
        // TODO Auto-generated method stub
        oldValue += direction;
        repaint();
        if(oldValue == newValue) {
            timer.stop();
        }
    }
 
    protected void drawGraduate(Graphics2D g2d) {
        g2d.setPaint(Color.white);
        g2d.drawString(String.valueOf(model.getValue()), 10, 20);
        g2d.drawString(String.valueOf(this.oldValue), 10, 40);
 
        g2d.draw(new Line2D.Double(150,190,150,10));
        for(int i = 10; i<191; i+=10) {
            if(i%20 == 10) {
                g2d.draw(new Line2D.Double(140,i,150,i));
            } else {
                g2d.draw(new Line2D.Double(145,i,150,i));
            }
 
        }
 
        g2d.drawImage(thumb,140-thumb.getWidth()-10,190-(thumb.getHeight()/2)-oldValue,thumb.getWidth(), thumb.getHeight(),null);
    }
 
    protected void drawBackground(Graphics2D g2d) {
        g2d.setPaint(Color.black);
        g2d.fill(new Rectangle2D.Double(0,0,getWidth()-1,getHeight()-1));
    }
 
 
    public static void main(String[] args) {
        final GraduationModel m = new GraduationModel();
        m.setValue(0);
        GraduationComponent c = new GraduationComponent(m);
        JFrame f = new JFrame();
        f.add(c);
        f.setSize(200,200);
        f.setLocationRelativeTo(null);
        f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        f.setVisible(true);
        Timer t = new Timer(5000,new ActionListener() {
 
            public void actionPerformed(ActionEvent e) {
                // TODO Auto-generated method stub
                m.setValue(m.getValue()+10);
            }
 
        });
        t.start();
 
 
    }
 
 
}

En ce qui concerne le dessin sur le composant c'est du vite fait mal fait (c'est moche, c'est une graduation droite & cie...

Mais le'essentiel pour toi est déja de comprendre les bases de la création d'un composant. A toi de faire le reste (calculs sur les rotations, courbes et les dessiner)

Vais pas te macher entièrement le taf non plus

Si tu as des questions... (désolé je n'ais pas franchement eu le temps de commenter mon code...)

[bouye]

Les methodes indiquees precedement sont bonnes mais il n'est pas vraiment necessaire que la fleche soit une image (surtout si elle est si simple) ; une simple Shape (un GeneralPath ou un Polygon) fera tout aussi bien l'affaire. Apres c'est la meme methode : utiliser une transformation affine pour la dessiner avec le bon angle.

Principe de base en 2D : en general, ne pas se prendre la tete en caculs complexe. Si tu sais tout dessiner a l'horizontal (resp a la verticale) autour de (0, 0) alors tu peux tout dessiner sous n'importe quel angle et a n'importe quel emplacement avec des transformations affines (et leur transformations inverses) de rotation et de translation (resp pour des transformation affines autre que des rotations).