Aller au menu - Aller au contenu

Icône Les cases à cocher : l'objet JCheckBox

Par Avatar cysboy
Mise à jour : 12/02/2010
Difficulté : Intermédiaire Intermédiaire Creative Commons BY-NC-SA
96 702 visites depuis 7 jours, dont 534 sur ce chapitre classé 4/786
Nous allons ici aborder un autre objet, mais comme je vous l'ai dit, le principe de fonctionnement est le même pour tous !
Nous allons donc pouvoir accélérer notre rythme d'apprentissage ! :p

Au passage, il y a un autre objet qui s'utilise quasiment de la même manière que celui-ci, nous le verrons donc en même temps dans ce chapitre !
Retour en haut
Sommaire du chapitre :
Icône du chapitre
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Premier exemple

Avant de commencer, nous allons nous familiariser avec cet objet dans un environnement vierge... Comme d'habitude :p .

Créez donc un projet vide avec une classe contenant une méthode main et une classe héritée de JFrame.

Lorsque vous créez un nouveau projet, comme ici, et que vous souhaitez utiliser une classe présente dans un autre projet, vous pouvez faire un copier-coller de celle-ci dans votre nouveau projet...
Ceci soit en faisant un clic droit > Copy, puis dans votre nouveau projet clic droit > Paste, soit avec le menu Edition en utilisant les mêmes commandes, ou encore avec les raccourcis clavier associés à ces commandes. On gagne du temps ! :D


Ceci fait, nous allons utiliser notre nouvel objet. Celui-ci peut être instancié avec un String en paramètre, ce paramètre servira de libellé à notre objet. Vu qu'il n'y a rien de compliqué à faire ceci, voici le code et le résultat :

Code : Java
 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
import java.awt.BorderLayout;
import java.awt.Color;
 
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
 
public class Fenetre extends JFrame {
        
        private JPanel container = new JPanel();
        private JCheckBox check1 = new JCheckBox("Case 1");
        private JCheckBox check2 = new JCheckBox("Case 2");
        private JLabel label = new JLabel("Une ComboBox");
        
        public Fenetre(){
        
        this.setTitle("Animation");
        this.setSize(300, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
 
        container.setBackground(Color.white);
        container.setLayout(new BorderLayout());
               
        JPanel top = new JPanel();
        top.add(check1);
        top.add(check2);
        
        container.add(top, BorderLayout.NORTH);
        this.setContentPane(container);
        this.setVisible(true);            
        }       
}


Résultat :

Image utilisateur


Vous pouvez aussi cocher la case en appelant la méthode setSelected(boolean bool) en lui passant true.
Cet objet a, comme tous les autres, une multitude de méthodes afin de pouvoir travailler, je vous invite aussi à fouiner un peu... :p

Créez maintenant une implémentation de l'interface ActionListener, vous connaissez bien la marche à suivre... Et contrôlez que votre objet est coché ou non avec la méthode isSelected() qui retourne un booléen ; voici un code mettant en oeuvre cette demande :

Code : Java
 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
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
 
public class Fenetre extends JFrame {
        
        private JPanel container = new JPanel();
        private JCheckBox check1 = new JCheckBox("Case 1");
        private JCheckBox check2 = new JCheckBox("Case 2");
        private JLabel label = new JLabel("Une ComboBox");
        
        public Fenetre(){
        
        this.setTitle("Animation");
        this.setSize(300, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
 
        container.setBackground(Color.white);
        container.setLayout(new BorderLayout());
               
        JPanel top = new JPanel();
        
        check1.addActionListener(new StateListener());
        check2.addActionListener(new StateListener());
        
        top.add(check1);
        top.add(check2);
        
        container.add(top, BorderLayout.NORTH);
        this.setContentPane(container);
        this.setVisible(true);            
        }       
        
        class StateListener implements ActionListener{
 
                public void actionPerformed(ActionEvent e) {
                        System.out.println("source : " + ((JCheckBox)e.getSource()).getText() + " - état : " + ((JCheckBox)e.getSource()).isSelected());
                }
                
        }
}


Résultat :

Image utilisateur



Ici, je me suis amusé à cocher et décocher mes cases. Rien de bien difficile ici, ça devient la routine... ^^
Retour en haut

Un pseudo-morphing pour notre animation

Nous allons utiliser cet objet afin de faire en sorte que nos formes changent de taille et nous donnent un pseudo-effet de morphing...

Que nous faut-il pour arriver à cela ?


Déjà, la taille de notre forme est fixe, il faut changer ça ! Allez, hop... Une variable de type int dans notre classe Panneau, disons drawSize, initialisée à 50.
Tout comme le déplacement, nous devons savoir quand augmenter ou réduire la taille de notre forme : nous utiliserons la même méthode que pour le déplacement.

Un deuxième booléen sera nécessaire pour savoir si le "mode morphing" est activé ou non...

En ce qui concerne la taille, si on réduit (ou augmente) celle-ci d'une unité à chaque rafraîchissement, l'effet de morphing sera ULTRA-RAPIDE. Donc, pour ralentir l'effet, nous allons utiliser une méthode qui va retourner 1 ou 0 selon le nombre de rafraîchissements. Ceci signifie que nous allons avoir besoin d'une variable pour dénombrer ceux-ci. Nous ferons une réduction (ou augmentation) tous les 10 tours !

Pour bien séparer les deux cas de figure, nous allons faire une deuxième méthode de dessin dans la classe Panneau qui aura pour rôle de dessiner le morphing ; appelons-la drawMorph(Graphics g).

Lorsque nous cocherons notre case à cocher, le morphing sera lancé, et inversement ! La classe Panneau devra donc avoir un mutateur pour le booléen de morphing... :p

Cependant, dans notre classe Fenetre, nous gérons la collision avec les bords... Mais en "mode morphing", la taille de notre forme n'est plus la même... Donc, il va falloir gérer ce nouveau cas de figure dans notre méthode go(). Notre classe Panneau devra avoir un accesseur pour la taille actuelle de la forme...

Vous avez tous les éléments en main pour réussir ceci.

Voici ce que vous devriez obtenir (je n'ai mis que le rond et le triangle... mais ça fonctionnera avec toutes les formes) :

Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur Image utilisateur


Voici les codes :
Secret (cliquez pour afficher)


Fichier Panneau.java



Code : Java
  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
import java.awt.Color;
import java.awt.Font;
import java.awt.GradientPaint;
import java.awt.Graphics;
import java.awt.Graphics2D;
 
import javax.swing.JPanel;
 
public class Panneau extends JPanel {
 
        private int posX = -50;
    private int posY = -50;
    private int drawSize = 50;
    //boolean pour le mode morphing et pour savoir si la taille doit réduire
    private boolean morph = false, reduce = false;;
    private String forme = "ROND";
    //Le compteur de rafraîchissements
    private int increment = 0;
    
    public void paintComponent(Graphics g){
            g.setColor(Color.white);
            g.fillRect(0, 0, this.getWidth(), this.getHeight());
            g.setColor(Color.red);
            //Si le mode morphing est activé, on peint le morphing
            if(this.morph)
                drawMorph(g);
            //sinon, mode normal
            else
                draw(g);       
    }
 
    private void draw(Graphics g){
        
        if(this.forme.equals("ROND")){
                g.fillOval(posX, posY, 50, 50); 
        }
        if(this.forme.equals("CARRE")){
                g.fillRect(posX, posY, 50, 50);
        }
        if(this.forme.equals("TRIANGLE")){
                 
                int s1X = posX + 50/2;
                int s1Y = posY;
                int s2X = posX + 50;
                int s2Y = posY + 50;
                int s3X = posX;
                int s3Y = posY + 50;
                
                int[] ptsX = {s1X, s2X, s3X};
                int[] ptsY = {s1Y, s2Y, s3Y};
                
                g.fillPolygon(ptsX, ptsY, 3);
        }
        if(this.forme.equals("ETOILE")){
                
                int s1X = posX + 50/2;
                int s1Y = posY;
                int s2X = posX + 50;
                int s2Y = posY + 50;                    
                g.drawLine(s1X, s1Y, s2X, s2Y);
                
                int s3X = posX;
                int s3Y = posY + 50/3;
                g.drawLine(s2X, s2Y, s3X, s3Y);
                
                int s4X = posX + 50;
                int s4Y = posY + 50/3;
                g.drawLine(s3X, s3Y, s4X, s4Y);                 
                                
                int s5X = posX;
                int s5Y = posY + 50;
                g.drawLine(s4X, s4Y, s5X, s5Y);                 
                g.drawLine(s5X, s5Y, s1X, s1Y);  
        }
        
    }
    
    /**
     * Méthode qui peint le morphing
     * @param g
     */
    private void drawMorph(Graphics g){
        //On incrémente le tour
        increment++;
        //On regarde si on doit réduire ou non
        if(drawSize >= 50)reduce = true;
        if(drawSize <= 10)reduce = false;
        
        if(reduce)
                drawSize = drawSize - getUsedSize();
        else
                drawSize = drawSize + getUsedSize();
        
        if(this.forme.equals("ROND")){
                g.fillOval(posX, posY, drawSize, drawSize); 
        }
        if(this.forme.equals("CARRE")){
                g.fillRect(posX, posY, drawSize, drawSize);
        }
        if(this.forme.equals("TRIANGLE")){
                  
                int s1X = posX + drawSize/2;
                int s1Y = posY;
                int s2X = posX + drawSize;
                int s2Y = posY + drawSize;
                int s3X = posX;
                int s3Y = posY + drawSize;
                
                int[] ptsX = {s1X, s2X, s3X};
                int[] ptsY = {s1Y, s2Y, s3Y};
                
                g.fillPolygon(ptsX, ptsY, 3);
        }
        if(this.forme.equals("ETOILE")){
                
                int s1X = posX + drawSize/2;
                int s1Y = posY;
                int s2X = posX + drawSize;
                int s2Y = posY + drawSize;              
                g.drawLine(s1X, s1Y, s2X, s2Y);
                
                int s3X = posX;
                int s3Y = posY + drawSize/3;
                g.drawLine(s2X, s2Y, s3X, s3Y);
                
                int s4X = posX + drawSize;
                int s4Y = posY + drawSize/3;
                g.drawLine(s3X, s3Y, s4X, s4Y);                 
                                
                int s5X = posX;
                int s5Y = posY + drawSize;
                g.drawLine(s4X, s4Y, s5X, s5Y);                 
                g.drawLine(s5X, s5Y, s1X, s1Y);  
        }
        
        
    }
    
    /**
     * Méthode qui retourne le nombre à retrancher (ou ajouter) pour le morphing
     * @return res
     */
    private int getUsedSize(){
        int res = 0;
        //Si le nombre de tours est de 10
        //On réinitialise l'incrément et on retourne 1
        if(increment / 10 == 1){
                increment = 0;
                res = 1;
        }       
        return res;
    }
    
    public int getDrawSize(){
        return drawSize;
    }
    
    public boolean isMorph(){
        return morph;
    }
    
    public void setMorph(boolean bool){
        this.morph = bool;
        //On réinitialise la taille
        drawSize = 50;
    }
    
    public void setForme(String form){
        this.forme = form;
    }
    
    public int getPosX() {
            return posX;
    }
 
    public void setPosX(int posX) {
            this.posX = posX;
    }
 
    public int getPosY() {
            return posY;
    }
 
    public void setPosY(int posY) {
            this.posY = posY;
    }
}


Fichier Fenetre.java



Code : Java
  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
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
 
public class Fenetre extends JFrame{
 
        private Panneau pan = new Panneau();
        private JButton bouton = new JButton("Go");
        private JButton bouton2 = new JButton("Stop");
    private JPanel container = new JPanel();
    private JLabel label = new JLabel("Choix de la forme");
    private int compteur = 0;
    private boolean animated = true;
    private boolean backX, backY;
    private int x,y ;
    private Thread t;
    private JComboBox combo = new JComboBox();
    
    private JCheckBox morph = new JCheckBox("Morphing");
    
    public Fenetre(){
           
            this.setTitle("Animation");
            this.setSize(300, 300);
            this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            this.setLocationRelativeTo(null);
 
            container.setBackground(Color.white);
            container.setLayout(new BorderLayout());
            container.add(pan, BorderLayout.CENTER);
            
            bouton.addActionListener(new BoutonListener());             
            bouton2.addActionListener(new Bouton2Listener());
            bouton2.setEnabled(false);
            
            JPanel south = new JPanel();
            south.add(bouton);
            south.add(bouton2);
            container.add(south, BorderLayout.SOUTH);
            
            combo.addItem("ROND");
            combo.addItem("CARRE");
            combo.addItem("TRIANGLE");
            combo.addItem("ETOILE");            
            combo.addActionListener(new FormeListener());
            
            morph.addActionListener(new MorphListener());
            
            JPanel top = new JPanel();
            top.add(label);
            top.add(combo);
            top.add(morph);
            
            container.add(top, BorderLayout.NORTH);
            this.setContentPane(container);
            this.setVisible(true);            
                        
    }
        
    
        private void go(){
                x = pan.getPosX();
                y = pan.getPosY();
        while(this.animated){
                
                //Si le mode morphing est activé, on utilise la taille actuelle de la forme
                if(pan.isMorph())
                {
                        if(x < 1)backX = false;
                    if(x > pan.getWidth() - pan.getDrawSize())backX = true;               
                    if(y < 1)backY = false;
                    if(y > pan.getHeight() - pan.getDrawSize())backY = true;
                }
                //Sinon, comme d'habitude
                else
                {
                        if(x < 1)backX = false;
                    if(x > pan.getWidth()-50)backX = true;               
                    if(y < 1)backY = false;
                    if(y > pan.getHeight()-50)backY = true;
                }  
            
                if(!backX)pan.setPosX(++x);
            else pan.setPosX(--x);
            if(!backY) pan.setPosY(++y);
            else pan.setPosY(--y);
            pan.repaint();
 
            try {
                    Thread.sleep(3);
            } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
            }
        }       
        }
 
        public class BoutonListener implements ActionListener{
 
                public void actionPerformed(ActionEvent arg0) {
                        animated = true;
                        t = new Thread(new PlayAnimation());
                        t.start();
                        bouton.setEnabled(false);
                        bouton2.setEnabled(true);                       
                }               
        }
        
        class Bouton2Listener  implements ActionListener{
 
                public void actionPerformed(ActionEvent e) {
                        animated = false;       
                        bouton.setEnabled(true);
                        bouton2.setEnabled(false);
                }               
        }       
        
        class PlayAnimation implements Runnable{
 
                public void run() {
                        go();                   
                }               
        }
        
        
        class FormeListener implements ActionListener{
 
                public void actionPerformed(ActionEvent e) {
                        pan.setForme(combo.getSelectedItem().toString());
                }               
        }
        
        class MorphListener implements ActionListener{
 
                public void actionPerformed(ActionEvent e) {
                        //Si la case est cochée, activation du mode morphing
                        if(morph.isSelected())pan.setMorph(true);
                        //Sinon, rien !
                        else pan.setMorph(false);
                }
                
        }
        
        
}



Alors ? Vous en pensez quoi ? :)
J'aime bien, moi...

Vous voyez que l'utilisation des JCheckBox est très simple... Je vous propose maintenant d'aller voir un de ses cousins... :p
Retour en haut

Les boutons radio : l'objet JRadioButton

Le voici, le cousin éloigné...

Bon, alors : le principe est de pouvoir avoir deux (ou plus) choix distincts, mais qu'un seul soit sélectionné à la fois... C'est-à-dire que pour un choix oui / non, le choix oui étant présélectionné, lorsque nous choisirons non, l'autre choix se désélectionnera tout seul... :p

L'instanciation se fait de la même manière que pour un JCheckBox ; d'ailleurs, nous allons utiliser l'exemple du début de chapitre en remplaçant les cases à cocher par des boutons radio. Voici les codes et le résultat :

Code : Java
 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 java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.JCheckBox;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
 
 
public class Fenetre extends JFrame {
        
        private JPanel container = new JPanel();
        
        private JRadioButton jr1 = new JRadioButton("Radio 1");
        private JRadioButton jr2 = new JRadioButton("Radio 2");
        
        public Fenetre(){
        
        this.setTitle("Animation");
        this.setSize(300, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
 
        container.setBackground(Color.white);
        container.setLayout(new BorderLayout());
               
        JPanel top = new JPanel();
        
        jr1.addActionListener(new StateListener());
        jr2.addActionListener(new StateListener());
        
        top.add(jr1);
        top.add(jr2);
        
        container.add(top, BorderLayout.NORTH);
        this.setContentPane(container);
        this.setVisible(true);            
        }       
        
        class StateListener implements ActionListener{
 
                public void actionPerformed(ActionEvent e) {
                        System.out.println("source : " + ((JRadioButton)e.getSource()).getText() + " - état : " + ((JRadioButton)e.getSource()).isSelected());
                }
                
        }
}


Résultat :

Image utilisateur


Vous pouvez voir que ces objets s'utilisent de la même manière. :D
Euh... Tu nous as dis que seul un choix devrait être sélectionné... Or ici, tes deux radios sont sélectionnés... o_O

Tout à fait... Voilà la différence entre ces deux objets... Pour qu'un seul bouton radio soit sélectionné à la fois, nous devons définir un groupe de boutons, ButtonGroup. Dans celui-ci, nous ajouterons nos boutons radio et ainsi seul un bouton sera sélectionné à la fois !

Code :

Code : Java
 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
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
 
import javax.swing.ButtonGroup;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JRadioButton;
 
 
public class Fenetre extends JFrame {
        
        private JPanel container = new JPanel();
        
        private JRadioButton jr1 = new JRadioButton("Radio 1");
        private JRadioButton jr2 = new JRadioButton("Radio 2");
        private ButtonGroup bg = new ButtonGroup();
        
        public Fenetre(){
        
        this.setTitle("Animation");
        this.setSize(300, 300);
        this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        this.setLocationRelativeTo(null);
 
        container.setBackground(Color.white);
        container.setLayout(new BorderLayout());
               
        JPanel top = new JPanel();
        
        jr1.setSelected(true);
        jr1.addActionListener(new StateListener());
        jr2.addActionListener(new StateListener());
        
        bg.add(jr1);
        bg.add(jr2);
        
        top.add(jr1);
        top.add(jr2);
        
        container.add(top, BorderLayout.NORTH);
        this.setContentPane(container);
        this.setVisible(true);            
        }       
        
        class StateListener implements ActionListener{
 
                public void actionPerformed(ActionEvent e) {
                        System.out.println("source : " + jr1.getText() + " - état : " + jr1.isSelected());
                        System.out.println("source : " + jr2.getText() + " - état : " + jr2.isSelected());
                }
                
        }
}


Résultat :

Image utilisateur


Une précision, toutefois... Lorsque je vous ai dit que la différence entre ces composants se trouvait dans cette notion de groupe de boutons... Je vous ai un peu induits en erreur :o .
En fait, j'ai dit ceci car il est plus fréquent d'avoir ce genre de chose sur des boutons de type radio que sur un autre, mais rien ne vous empêche de faire la même chose pour des cases à cocher...
Effectivement, l'objet ButtonGroup accepte en paramètre un type AbstractButton qui est la super-classe de tous les boutons... Vous pouvez donc en tirer les conclusions qui s'imposent !
Retour en haut

Ce qu'il faut retenir

  • Les objets JCheckBox, JRadioButton et ButtonGroup sont dans le package javax.swing
  • Vous pouvez savoir si un de ces composants est sélectionné grâce à la méthode isSelected().
  • Cette méthode retourne true si l'objet est sélectionné, et false dans le cas contraire.
  • Vous pouvez restreindre les choix dans un groupe de réponses en utilisant la classe ButtonGroup.
  • Vous pouvez ajouter des boutons à un groupe de boutons grâce à la méthode add(AbstractButton button).


Allez... Pas besoin de QCM ici... Il n'y a rien de compliqué ! ;)
Retour en haut
Je sens que vous êtes de plus en plus à l'aise avec la programmation événementielle !
Continuons donc avec : les zones de texte.
Chapitre précédent Sommaire Chapitre suivant
Retour en haut

Partager

Retour en haut
4 commentaires pour "Les cases à cocher : l'objet JCheckBox"
Note moyenne : 3.57 / 4 (1025 votes)
Pseudo Commentaire
Hors ligne Gingi # Posté le 08/03/2009 à 22:33:08
Loi / justice c'est diférent
Avatar

 Cela me désole qu'il n'y ai pas de post ici. :(

Merci à toi Cysboy ! ;)
Recherche designer pour projet communautaire sur le manga: à voir ICI
 
Hors ligne Afnarel # Posté le 09/04/2009 à 19:09:22
Avatar

Études : IUT Bordeaux 1

 Tu crées un JLabel "Une ComboBox" dans les deux premiers codes mais tu ne l'utilises jamais. Probablement un oubli de rectification après un copier/coller de la classe du chapitre précédent... :)

Citation : Tuto
Créez maintenant une implémentation de l'interface ActionPerformed

Il me semble que l'interface s'appelle ActionListener. ActionPerformed n'est qu'une méthode à implémenter...

Pour le morphisme, il à mon avis bien plus simple de créer une variable static que l'on incrémente dans la méthode paintComponent puis de tester si cetteVariable%10==0. Au pire, si on craint un dépassement de la taille maximale autorisée par le type de la variable créée, on fait un test pour que quand elle atteint une trop grande taille elle soit remise à 0.

J'en profite pour te remercier pour ce tutoriel (même si ça serait bien que tu lises les commentaires de chaque chapître et que tu rectifies les erreurs qui ont été relevées quand tu auras du temps) et pour le tutoriel sur la programmation d'applications web avec JEE que je compte lire dès que j'aurai fini celui-là :)

Bonne continuation...
Une distribution à découvrir :
http://www.archlinux.org/
http://archlinux.fr/

Un window manager minimaliste :
http://awesome.naquadah.org/
 
Hors ligne negstek # Posté le 21/01/2010 à 23:51:20
Que la zForce soit avec toi !!
Avatar

Avis : Très bon

Ville : Le havre
Pays : France métropolitaine

 Après avoir galéré un peu, j'ai enfin compris que la fenêtre était trop petite pour faire apparaître la comboBox. Il n'y avait donc pas besoin de retourner tout le code pour corriger le "bogue".

Finalement après un rapide changement de sa taille (500 au lieu de 300), ce tuto est franchement redevenu sympathique...

@ +

 
Hors ligne koyuki38 # Posté le 23/03/2012 à 13:55:57

Études : INSAT

 les objets sont facil à utiliser, par contre, changer l'animation pour la rendre plus petite, c'est juste ignoblement difficile (et pour pas grand chose en plus)

Voir tous les commentaires