LECON 308


Les cases à cocher : l'objet JCheckBox
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 !

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 !
Sommaire du chapitre :

  • Premier exemple
  • Un pseudo-morphing pour notre animation
  • Les boutons radio : l'objet JRadioButton
  • Ce qu'il faut retenir

Premier exemple

Avant de commencer, nous allons nous familiariser avec cet objet dans un environnement vierge... Comme d'habitude.
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 !


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 :


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

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 :



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

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

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







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

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éa tout seul...

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 :


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

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 :

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

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é !
Je sens que vous êtes de plus en plus à l'aise avec la programmation événementielle !
Continuons donc avec : les zones de texte.

// // 0 comments //

0 comments to "LECON 308"

Post a Comment

Powered by Blogger.

About This Blog

Aller au debut de la page